JavaScript :簡稱:js

js分三個部分:
1. ECMAScript 標準----js的基本的語法
2. DOM------Document Object Model 文檔對象模型
3. BOM------Browser Object Model 瀏覽器對象模型

JavaScript是什么血公？
是一門腳本語言
是一門解釋性語言
是一門動態(tài)類型的語言
是一門基于對象的語言

編譯語言:需要把代碼翻譯成計算機所認知的二進制語言,才能夠執(zhí)行
腳本語言:不需要編譯,直接執(zhí)行
常見的腳本語言:t-sql,cmd

電腦的硬件---->系統(tǒng)--->客戶端的程序--->代碼
電腦的硬件---->系統(tǒng)--->瀏覽器--->js代碼
js原名不是JavaScript,而是LiveScript
js的作用?解決用戶和瀏覽器之間的交互的問題
js現(xiàn)在可以做什么?

* HTML:是標記語言,展示數(shù)據(jù)的
* CSS:美化頁面
* JavaScript:用戶和瀏覽器交互,

js的代碼可以分三個地方寫:

1.在html的文件中,script的標簽中寫js代碼
2.js代碼可以在html的標簽中寫---
3.在js文件中可以寫js代碼,但是需要在html的頁面中引入 script的標簽中的src="js的路徑"

變量

操作的數(shù)據(jù)都是在內(nèi)存中操作
* js中存儲數(shù)據(jù)使用變量的方式(名字,值--->數(shù)據(jù))
* js中聲明變量都用var---->存儲數(shù)據(jù),數(shù)據(jù)應(yīng)該有對應(yīng)的數(shù)據(jù)類型
* js中的字符串類型的值都用雙引號或者單引號

• 變量---作用,存儲數(shù)據(jù)的或者是操作數(shù)據(jù)

  • 變量聲明(有var 有變量名字,沒有值)

  • 變量初始化(有var 有變量名字,有值)

  • 變量聲明的方式:

  • var 變量名字;

    //存儲一個數(shù)字10
    var number = 10;
    //存儲一個5
    var number2 = 5;
    //存儲一個人的名字
    var name = "小黑";
    //存儲真(true)
    var flag = true;
    //存儲一個null--->相當于是空
    var nll = null;
    //存儲一個對象
    var obj = new Object();

js中的原始數(shù)據(jù)類型:

number,string,boolean,null,undefined,object

number:數(shù)字類型(整數(shù)和小數(shù))
string:字符串類型(的值一般都是用單引號或者是雙引號括起來) "34"
boolean:布爾類型(值只有兩個,true(真1),false(假0))
null:空類型,值只有一個:null,一個對象指向為空了,此時可以賦值為null
undefined:未定義,值只有一個:undefined

操作符:一些符號-----用來計算

• 算數(shù)運算符: + - * / %
  • 算數(shù)運算表達式:由算數(shù)運算符連接起來的表達式
  • 一元運算符: 這個操作符只需要一個操作數(shù)就可以運算的符號 ++ --
  • 二元運算符: 這個操作符需要兩個操作數(shù)就可以運算,
  • 三元運算符:
  • 復(fù)合運算符: += -= *= /= %=
  • 復(fù)合運算表達式:由復(fù)合運算符連接起來的表達式
  • var num=10;
  • num+=10;------>就是:num=num+10;
  • console.log(num);20
  • 關(guān)系運算符: > < >= <= ==不嚴格的 ===嚴格的 !=不嚴格的不等 !==嚴格的不等
  • 關(guān)系運算表達式:由關(guān)系運算符連接起來的表達式
  • 關(guān)系運算表達式的結(jié)果是布爾類型
  • 邏輯運算符:
  • &&---邏輯與--并且
  • ||---邏輯或---或者
  • !---邏輯非---取反--取非
  • 邏輯運算表達式:由邏輯運算符連接起來的表達式
  • 表達式1&&表達式2
  • 如果有一個為false,整個的結(jié)果就是false
  • 表達式1||表達式2
  • 如果有一個為true,整個的結(jié)果為true
  • !表達式1
  • 表達式1的結(jié)果是true,整個結(jié)果為false
  • 表達式1的結(jié)果是false,整個結(jié)果為true
    賦值運算符: =

流程控制；代碼的執(zhí)行過程

1.順序結(jié)構(gòu):從上到下,從左到右執(zhí)行的順序,就叫做順序結(jié)構(gòu)(不是很眼睛)
2.分支結(jié)構(gòu):if語句,if-else語句,if-else if-else if...語句,switch-case語句,三元表達式語句
3.循環(huán)結(jié)構(gòu):while循環(huán),do-while循環(huán),for循環(huán),后期還有一個for-in循環(huán)

if語句:主要是判斷

語法:
if(表達式){
代碼塊
}
執(zhí)行過程:
先判斷表達式的結(jié)果是true還是false,如果是true則執(zhí)行代碼塊,如果是false,大括號中的代碼是不執(zhí)行的

if-else 語句

語法:
if-else語句的語法:
if(表達式){
代碼1
}else{
代碼2
}
執(zhí)行過程:
如果表達式的結(jié)果是true則執(zhí)行代碼1,如果表達式的結(jié)果是false,則執(zhí)行代碼2

三元表達式

運算符號: ? :
語法:
var 變量=表達式1?表達式2:表達式3;
執(zhí)行過程:
表達式1的結(jié)果是true還是false,如果是true則執(zhí)行表達式2,然后把結(jié)果給變量 如果表達式1的結(jié)果是false,則執(zhí)行表達式3,把結(jié)果給變量

if-else if語句...

語法:
if(表達式1){
代碼1
}else if(表達式2){
代碼2
}else if(表達式3){
代碼3
}else{
代碼4
}
else if---這種結(jié)構(gòu)可以寫多個,具體多少個看需求, else--結(jié)構(gòu)是可以不用寫的,具體也是看需求
執(zhí)行過程:
先判斷表達式1的結(jié)果,
如果為true則執(zhí)行代碼1
如果為false,則判斷表達式2
如果表達式2為true則執(zhí)行代碼2
如果為false,則判斷表達式3
如果表達式3為true則執(zhí)行代碼3
否則執(zhí)行代碼4

switch-case語句

語法:
switch(表達式){
case 值1:代碼1;break;
case 值2:代碼2;break;
case 值3:代碼3;break;
case 值4:代碼4;break;
...多個case
default:代碼5;
}
執(zhí)行過程:
獲取表達式的值,和值1比較,如果一樣,則執(zhí)行代碼1,遇到break則跳出整個的語句,后面代碼不執(zhí)行
如果表達式的值和值1不一樣,則和值2比較,如果相同則執(zhí)行代碼2,遇到break則跳出
否則和值3比較,相同則執(zhí)行代碼3,遇到break,跳出,否則和值4比較,相同則執(zhí)行代碼4,遇到break則跳出,否則直接執(zhí)行代碼5

while循環(huán)

while循環(huán)語法:

計數(shù)器
var 變量=0;
while(循環(huán)的條件){
循環(huán)體;
計數(shù)器++;
}

• 先判斷條件是否成立,(條件的結(jié)果是true還是false),如果是false,那么循環(huán)的代碼(while的大括號中的代碼都不執(zhí)行),如果是true,那么先執(zhí)行循環(huán)體,然后執(zhí)行計數(shù)器,然后,直接去--->循環(huán)的條件,再次判斷是否成立,成立則繼續(xù)執(zhí)行循環(huán)體,否則跳出循環(huán),執(zhí)行完循環(huán)體之后,計數(shù)器加1,然后再去循環(huán)的條件,判斷,成立則循環(huán),否則跳出循環(huán)

 var i=0;
 while(i<20){
 循環(huán)體
 i++;
 }

do-while循環(huán)

語法:
do{
循環(huán)體
}while(條件);

執(zhí)行過程:
先執(zhí)行一次循環(huán)體,然后判斷條件是否成立,不成立,則跳出循環(huán),成立則執(zhí)行循環(huán)體,然后再判斷條件是否成立,成立則繼續(xù)循環(huán),否則跳出.....

    var i = 1;
    var sum = 0;
    do {
      if (i % 3 == 0) {
        sum += i;
      }
      i++;
    } while (i <= 100);
    console.log(sum);

while循環(huán)特點:先判斷,后循環(huán),有可能一次循環(huán)體都不執(zhí)行
do-while循環(huán)特點:先循環(huán),后判斷,至少執(zhí)行一次循環(huán)體

for循環(huán)

語法:
for(表達式1;表達式2;表達式3){
循環(huán)體;
}

執(zhí)行過程:
先執(zhí)行一次表達式1,然后判斷表達式2;如果不成立則直接跳出循環(huán)
如果表達式2成立,執(zhí)行循環(huán)體的代碼,結(jié)束后,跳到表達式3執(zhí)行,然后跳到表達式2,判斷表達式2是否成立,不成立,則跳出循環(huán)
如果表達式2成立,則執(zhí)行循環(huán)體,然后再跳到表達式3,再跳到表達式2,判斷是否成立,一直如此

    var sum = 0;
    for (var i = 1; i <= 100; i++) {
      sum += i;
    }
    console.log("和為:" + sum);

break關(guān)鍵字:如果在循環(huán)中使用,遇到了break,則立刻跳出當前所在的循環(huán)

    for(var i=100;i<=200;i++){
      if(i%7==0){
        console.log(i);
        break;
      }
    }

continue:在循環(huán)中如果遇到continue關(guān)鍵字,直接開始下一次循環(huán)

    var sum=0;
    var i=1;
    while(i<=10){
      if(i%10==3){
        //個位數(shù)是3,不要
        i++;
        continue;
      }
      sum+=i;
      i++;
    }
    console.log(sum);

數(shù)組:一組有序的數(shù)據(jù)

數(shù)組的作用:可以一次性存儲多個數(shù)據(jù)
數(shù)組的定義:

1. 通過構(gòu)造函數(shù)創(chuàng)建數(shù)組
   var 數(shù)組名=new Array();
   var array=new Array(); 定義了一個數(shù)組
   var 數(shù)組名=new Array(長度)

如果數(shù)組中沒有數(shù)據(jù),但是有長度---,數(shù)組中的每個值就是undefined
構(gòu)造函數(shù)的方式創(chuàng)建數(shù)組的時候,如果在Array(一個數(shù)字)--->數(shù)組的長度(數(shù)組元素的個數(shù))
如果在Array(多個值);這個數(shù)組中就有數(shù)據(jù)了,數(shù)組的長度就是這些數(shù)據(jù)的個數(shù)

2. 通過字面量的方式創(chuàng)建數(shù)組
   var 數(shù)組名=[ ];空數(shù)組
   var array=[ ];

數(shù)組:一組有序的數(shù)據(jù)
數(shù)組元素:數(shù)組中存儲的每個數(shù)據(jù),都可以叫數(shù)組的元素,比如:存儲了3個數(shù)據(jù),數(shù)組中3個元素
數(shù)組長度:就是數(shù)組的元素的個數(shù),比如有3個元素,就說,這個數(shù)組的長度是3
數(shù)組索引(下標):用來存儲或者訪問數(shù)組中的數(shù)據(jù)的,索引從0開始,到長度減1結(jié)束
數(shù)組的索引和數(shù)組的長度的關(guān)系:長度減1就是最大的索引值

通過構(gòu)造函數(shù)的方式定義一個數(shù)組

var array=new Array(5);//沒有數(shù)據(jù),空數(shù)組
console.log(array);
alert(array);

 就是一個數(shù)組---->字面量的方式
 var arr=[];
 console.log(arr);

var arr3=new Array(10,20,1000,40,50,60);
console.log(arr3);

 var arr=new Array(10,20,30,40,100);
  //console.log(arr[4]);//獲取
  //設(shè)置
 arr[3]=1000;
 console.log(arr);

 字面量的方式更簡單

 var arr=[10,20,30,40,50,60,70,80,10,20,3043,5];//空數(shù)組
 console.log(arr.length);

數(shù)組知識的總結(jié)

數(shù)組:存儲一組有序的數(shù)據(jù)
數(shù)組的作用:一次性存儲多個數(shù)據(jù)
數(shù)組的定義方式:
1.構(gòu)造函數(shù)定義數(shù)組: var 數(shù)組名=new Array();
2.字面量方式定義數(shù)組: var 數(shù)組名=[];
var 數(shù)組名=new Array();空數(shù)組
var 數(shù)組名=new Array(值);數(shù)組定義了,有長度
var 數(shù)組名=new Array(值1,值2,值3....);定義數(shù)組并且有多個數(shù)據(jù)
var 數(shù)組名=[];空數(shù)組
var 數(shù)組名=[值1,值2,值3];有三個數(shù)據(jù)
數(shù)組元素:就是數(shù)組中存儲的數(shù)據(jù)
數(shù)組長度:就是數(shù)組中元素的個數(shù)
數(shù)組索引(下標):從0開始,到數(shù)組的長度減1結(jié)束
通過下標設(shè)置數(shù)組的元素值: 數(shù)組名[索引]=值
通過下標訪問數(shù)組的元素值: 數(shù)組名[索引]

    var arr1=new Array();//空數(shù)組
    var arr2=new Array(5);//長度為5的數(shù)組,每個數(shù)據(jù)的值是undefined
    var arr3=new Array(1,2,3,4,5);//長度為5分數(shù)組,
    var arr4=[];//空數(shù)組
    var arr5=[1,2,3];//長度為3的數(shù)組
    var arr6=["red","blue","green",1,true];//數(shù)組中元素的值的類型可以不一樣

    var arr7=[];
    //設(shè)置數(shù)組的元素的值
    arr7[0]=10;
    arr7[1]=20;

遍歷數(shù)組

    var arr=[10,20,30,40,50,60,70,80,90,100];
//小于的是數(shù)組的長度--個數(shù)
    for(var i=0;i<arr.length;i++){
      console.log(arr[i]);
    }

冒泡排序:把所有的數(shù)據(jù)按照一定的順序進行排列(從小到大,從大到下)

    var arr = [10, 0, 100, 20, 60, 30];
    //循環(huán)控制比較的輪數(shù)
    for (var i = 0; i < arr.length - 1; i++) {
      //控制每一輪的比較的次數(shù)
      for (var j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] < arr[j + 1]) {
          var temp = arr[j];
          arr[j] = arr[j + 1];
          arr[j + 1] = temp;
        }
      }
    }
    console.log(arr);

函數(shù):把一坨重復(fù)的代碼封裝,在需要的時候直接調(diào)用即可

函數(shù)的作用:代碼的重用
語法:

function 函數(shù)名字(){
  函數(shù)體-----一坨重復(fù)的代碼
 }

函數(shù)參數(shù):

形參:函數(shù)在定義的時候小括號里的變量叫形參
實參:函數(shù)在調(diào)用的時候小括號里傳入的值叫實參,實參可以是變量也可以是值

函數(shù)的返回值

在函數(shù)內(nèi)部有return關(guān)鍵字,并且在關(guān)鍵字后面有內(nèi)容,這個內(nèi)容被返回了
當函數(shù)調(diào)用之后,需要這個返回值,那么就定義變量接收,即可

• 如果一個函數(shù)中有return ,那么這個函數(shù)就有返回值
• 如果一個函數(shù)中沒有return,那么這個函數(shù)就沒有返回值
  如果一個函數(shù)中沒有明確的返回值,那么調(diào)用的時候接收了,結(jié)果就是undefined
  (沒有明確返回值:函數(shù)中沒有return,函數(shù)中有return,但是return后面沒有任何內(nèi)容)
  函數(shù)沒有返回值,但是在調(diào)用的時候接收了,那么結(jié)果就是undefined
  變量聲明了,沒有賦值,結(jié)果也是undefined
  如果一個函數(shù)有參數(shù),有參數(shù)的函數(shù)
  如果一個函數(shù)沒有參數(shù),沒有參數(shù)的函數(shù)
  形參的個數(shù)和實參的個數(shù)可以不一致
  return 下面的代碼是不會執(zhí)行的

   function getSum(x, y) {
     var sum = x + y;
     return sum;//把和返回

   }
   //函數(shù)調(diào)用
   var result=getSum(10, 20);
   console.log(result+10);



    函數(shù)定義: 有參數(shù)有返回值的函數(shù)
   function getSum(x, y) {
     return  x + y;//把和返回
   }
   //函數(shù)調(diào)用
   var result=getSum(10, 20);
   console.log(result+10);



    有參數(shù),有返回值的函數(shù)
   function f1(x,y) {
     return x+y;
   }
   //有參數(shù),無返回值的函數(shù)
   function f2(x) {
     console.log(x);
   }
   //無參數(shù),有返回值的函數(shù)
   function f3() {
     return 100;
   }
   //無參數(shù)無返回值的函數(shù)
   function f4() {
     console.log("薩瓦迪卡");
   }


   var sum=f1(10);
   console.log(sum);//

arguments----->數(shù)組使用------偽數(shù)組---

使用arguments對象可以獲取傳入的每個參數(shù)的值
    function f1() {
      var sum=0;
      for(var i=0;i<arguments.length;i++){
        sum+=arguments[i];
      }
      return sum;
    }

    console.log(f1(10,20,30));

命名函數(shù)和匿名函數(shù)

函數(shù)如果有名字,就是命名函數(shù).
函數(shù)如果沒有名字,就是匿名函數(shù)
函數(shù)的另一種定義方式
函數(shù)表達式:把一個函數(shù)給一個變量,此時形成了函數(shù)表達式
var 變量=匿名函數(shù)

 var f1=function (){
  
  };
//如果是函數(shù)表達式,那么此時前面的變量中存儲的就是一個函數(shù),而這個變量就相當于是一個函數(shù),就可以直接加小括號調(diào)用了

函數(shù)可以作為參數(shù)使用,如果一個函數(shù)作為參數(shù),那么我們說這個參數(shù)(函數(shù))可以叫回調(diào)函數(shù)

//函數(shù)聲明,fn是變量,fn是參數(shù),
   function f1(fn) {
     fn();//函數(shù)調(diào)用---說明fn這個變量中存儲的是一個函數(shù)
   }

   function f2() {
     console.log("哦,這也可以");
   }
   f1(f2);

作用域

全局變量:聲明的變量是使用var聲明的,那么這個變量就是全局變量,全局變量可以在頁面的任何位置使用
除了函數(shù)以外,其他的任何位置定義的變量都是全局變量 局部變量:在函數(shù)內(nèi)部定義的變量,是局部變量,外面不能使用 全局變量,如果頁面不關(guān)閉,那么就不會釋放,就會占空間,消耗內(nèi)存

全局作用域:全局變量的使用范圍
局部作用域:局部變量的使用范圍

塊級作用域:一對大括號就可以看成是一塊,在這塊區(qū)域中定義的變量,只能在這個區(qū)域中使用,但是在js中在這個塊級作用域中定義的變量,外面也能使用;
說明:js沒有塊級作用域,只有函數(shù)除外
隱式全局變量:聲明的變量沒有var,就叫隱式全局變量
全局變量是不能被刪除的,隱式全局變量是可以被刪除的
定義變量使用var是不會被刪除的,沒有var是可以刪除的

預(yù)解析:就是在解析代碼之前

預(yù)解析做什么事?
把變量的聲明提前了----提前到當前所在的作用域的最上面
函數(shù)的聲明也會被提前---提前到當前所在的作用域的最上面

編程思想

編程思想:把一些生活中做事的經(jīng)驗融入到程序中
面向過程:凡事都要親力親為,每件事的具體過程都要知道,注重的是過程
面向?qū)ο?根據(jù)需求找對象,所有的事都用對象來做,注重的是結(jié)果
面向?qū)ο筇匦?封裝,繼承,多態(tài) (抽象性)
js不是面向?qū)ο蟮恼Z言,但是可以模擬面向?qū)ο蟮乃枷?br> js是一門基于對象的語言:
萬物皆對象:

創(chuàng)建對象三種方式:

1.調(diào)用系統(tǒng)的構(gòu)造函數(shù)創(chuàng)建對象
var 變量名= new Object(); Object 是系統(tǒng)的構(gòu)造函數(shù) Array

    //實例化對象
    var obj = new Object();
    //對象有特征---屬性和行為---方法
    //添加屬性-----如何添加屬性?  對象.名字=值;
    obj.name = "小蘇";
    obj.age = 38;
    obj.sex = "女";
    //添加方法----如何添加方法? 對象.名字=函數(shù);
    obj.eat = function () {
      console.log("我喜歡");
    };

2.自定義構(gòu)造函數(shù)創(chuàng)建對象(結(jié)合第一種和需求通過工廠模式創(chuàng)建對象)

    function createObject(name,age) {
      var obj = new Object();//創(chuàng)建對象
      //添加屬性
      obj.name = name;
      obj.age = age;
      //添加方法
      obj.sayHi = function () {
        console.log("阿涅哈斯誒呦,我叫:" + this.name + "我今年:" + this.age);
      };
      return obj;
    }
    //創(chuàng)建人的對象
    var per1 = createObject("小芳",20);
    per1.sayHi();
    //創(chuàng)建一個人的對象
    var per2 = createObject("小紅",30);
    per2.sayHi();

作用:一次性創(chuàng)建多個對象,把創(chuàng)建對象的代碼封裝在一個函數(shù)中

3.字面量的方式創(chuàng)建對象
字面量創(chuàng)建對象的缺陷: 一次性的對象

    var obj={};
    obj.name="小白";
    obj.age=10;
    obj.sayHi=function () {
      console.log("我是:"+this.name);
    };
    obj.sayHi();

函數(shù)和構(gòu)造函數(shù)的區(qū)別；名字是不是大寫(首字母是大寫)

    function Person(name,age) {
      this.name=name;
      this.age=age;
      this.sayHi=function () {
        console.log("我叫:"+this.name+",年齡是:"+this.age);
      };
    }

自定義構(gòu)造函數(shù)創(chuàng)建對象:先自定義一個構(gòu)造函數(shù),創(chuàng)建對象

    var obj=new Person("小明",10);
    console.log(obj.name);
    console.log(obj.age);
    obj.sayHi();

    var obj2=new Person("小紅",20);
    console.log(obj2.name);
    console.log(obj2.age);
    obj2.sayHi();


    console.log(obj instanceof Person);
    console.log(obj2 instanceof  Person);

JSON格式的數(shù)據(jù):一般都是成對的,是鍵值對,

json也是一個對象,數(shù)據(jù)都是成對的,一般json格式的數(shù)據(jù)無論是鍵還是值都是用雙引號括起來的

    var json = {
      "name": "小明",
      "age": "10",
      "sex": "男"
    };

遍歷對象,是不能通過for循環(huán)遍歷,無序
key是一個變量,這個變量中存儲的是該對象的所有的屬性的名字

for (var key in json) {
      console.log(key + "===========" + json[key]);
    }

js學(xué)習(xí)中三種對象

1.內(nèi)置對象----js系統(tǒng)自帶的對象
2.自定義對象---自己定義的構(gòu)造函數(shù)創(chuàng)建的對象
3.瀏覽器對象---BOM

內(nèi)置對象: Math Date String Array Object

Math.PI----π---
Math.E----常數(shù)的底數(shù)
Math.abs(值)-----絕對值
Math.ceil(值)----向上取整
Math.floor(值)---向下取整
Math.random---隨機數(shù)字
Math.sqrt()----開平方
Math.pow()----一個數(shù)字的多少次冪

Date

   var dt=new Date();
   var dt=+new Date();//一種特殊的寫法,只適用于這個Date的對象
   console.log(dt);

   dt.getFullYear();//年
   dt.getMonth();//月---從0開始
   dt.getDate();//日
   dt.getHours();//小時
   dt.getMinutes();//分鐘
   dt.getSeconds();//秒
   dt.getDay();//星期---從0開始
   dt.toDateString();//日期
   dt.toLocaleDateString();//日期
   dt.toTimeString();//時間
   dt.toLocaleTimeString();//時間
   dt.valueOf();//毫秒

字符串的常用屬性:
length------>字符串的長度
charAt(索引),返回值是指定索引位置的字符串,超出索引,結(jié)果是空字符串
fromCharCode(數(shù)字值,可以是多個參數(shù)),返回的是ASCII碼對應(yīng)的值
concat(字符串1,字符串2,...);返回的是拼接之后的新的字符串
indexOf(要找的字符串,從某個位置開始的索引);返回的是這個字符串的索引值,沒找到則返回-1
lastIndexOf(要找的字符串);從后向前找,但是索引仍然是從左向右的方式,找不到則返回-1
replace("原來的字符串","新的字符串");用來替換字符串的
slice(開始的索引,結(jié)束的索引); 從索引5的位置開始提取,到索引為10的前一個結(jié)束,沒有10褒傅，并返回這個提取后的字符串
split("要干掉的字符串",切割后留下的個數(shù));切割字符串
substr(開始的位置,個數(shù));返回的是截取后的新的字符串
substring(開始的索引,結(jié)束的索引),返回截取后的字符串,不包含結(jié)束的索引的字符串
toLocaleLowerCase();轉(zhuǎn)小寫
toLowerCase();轉(zhuǎn)小寫
toLocaleUpperCase()轉(zhuǎn)大寫
toUpperCase();轉(zhuǎn)大寫
trim();干掉字符串兩端的空格

Array.isArray(對象)---->判斷這個對象是不是數(shù)組

instanceof關(guān)鍵字
concat(數(shù)組,數(shù)組,數(shù)組,...) 組合一個新的數(shù)組
every(函數(shù))--返回值是布爾類型,函數(shù)作為參數(shù)使用,函數(shù)中有三個參數(shù),第一個參數(shù)是元素的值桐臊，第二個參數(shù)是索引值,第三個參數(shù)是原來的數(shù)組(沒用)
如果這個數(shù)組中的每個元素的值都符合條件,最后才返回的是true
filter(函數(shù));返回的是數(shù)組中每一個元素都復(fù)合條件的元素,組成了一個新的數(shù)組
push(值);--->把值追加到數(shù)組中,加到最后了---返回值也是追加數(shù)據(jù)之后的數(shù)組長度
pop();--->刪除數(shù)組中最后一個元素,返回值就是刪除的這個值
shift();--->刪除數(shù)組中第一個元素,返回值就是刪除的這個值
unshift();--->向數(shù)組的第一個元素前面插入一個新的元素,----返回值是插入后的程度
forEach(函數(shù))方法---遍歷數(shù)組用---相當于for循環(huán)
indexOf(元素值);返回的是索引,沒有則是-1
join("字符串");----返回的是一個字符串
map(函數(shù));--->數(shù)組中的每個元素都要執(zhí)行這個函數(shù),把執(zhí)行后的結(jié)果重新的全部的放在一個新的數(shù)組中
reverse();----->反轉(zhuǎn)數(shù)組
sort();---排序的,可能不穩(wěn)定,如果不穩(wěn)定,請寫MDN中的那個固定的代碼
arr.slice(開始的索引,結(jié)束的索引);把截取的數(shù)組的值放在一個新的數(shù)組中,但是不包含結(jié)束的索引對應(yīng)的元素值
splice(開始的位置,要刪除的個數(shù),替換的元素的值);一般是用于刪除數(shù)組中的元素,或者是替換元素,或者是插入元素