JS分为三个部分
JavaScript是什么
一门运行在客户端的脚本语言、一门解释性语言、一门动态类型的语言、一门基于对象的语言。
编译语言：需要把代码翻译成计算机所认知的二进制语言，才能够执行；脚本语言：不需要霸译，直接执行，常见的脚本语言有t-sql，cmd。
JS应用场景
什么是变量
变量是计算机内存中存储数据的标识符，根据变量名称可以获取到内存中存储的数据
如何使用
var age
var age=18
var num1 num2 num3
num1=1;
num2=2;
num3=3
var num1=1 num2=2 nume=e
+ - * %, /(取余)——加减乘除++ --——只需要一个操作数即可计算var num=10
num++ //10
++num //10
num++ +10 //20
++num +10 //21
//num++先参与运算后才自身++，
//++num先自身++后再参与运算
+ - * % /——需要两个操作数+= -= *= /= %=num+=10
num=num+10
> < >= <= == === != !==var str="5"
var num=5
console.log(str==num)//true，==不严格，只需要值相等而数据类型不一定
console.log(str===num)//false ===严格，要求值与数据类型都相等
&& || ！在js中，无论是单引号还是双引号都是字符串，它可以看成一个数组
用“+”连接，拼接两个字符串。如果另一个是数字，不会计算结果；如果其中一个字符串里面是数字，另一个是数字，用的不是“+”，会隐式转换，有计算结果
除了普通的可打印字符以外，一些特殊有特殊功能的字符可以通过转义字符的形式放入字符串中
| 转义序列 | 含义 |
|---|---|
| \n | 换行 |
| \r | 回车 |
| " | 双引号 |
【false】判断为flase的几种情况：
1. undefined（未定义，找不到值时出现）
2. null
3. false（布尔值的false，字符串"false"布尔值为true）
4. 0（数字0，字符串"0"布尔值为true）
5. NaN（无法计算结果时出现，表示"非数值"）
6. ""或‘‘（空字符串,空格时为true）
【注意】空数组空对象，负值转的布尔值时都为true
表示一个空，变量的值如果想为null，必须手动设置
声明而没有赋值；函数没有明确返回值
var arr=new Array(5)//数组内有五个undefined元素
var arr=new Array(5,6,7,8)//[5,6,7,8]
arr.lengtharr[0]//案例1：去掉数组中重复的0
var arr=[1,0,3,0,5,0,7]
var newArr=[]
for(var i=0;i<arr.length;i++){
if(arr[i]!=0){
newArr[newArr.length]=arr[i]
}
}
//案例2：冒泡排序从小到大
var arr=[10，0，100，20，60，30]；
for（var i=0；i<arr.length-1；i++）{
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;
}
}
}
//函数声明
function funcName(){函数体}
//函数调用
funcName()
//函数声明
function(){}
//调用方法1：把函数给一个变量才能调用，这里称为函数表达式
var f1=function(){}
f1()
//调用方法2：将函数包裹在括号内，也称自调用函数
(function(){})()
形参：函数在定义的时候括号里面的变量叫做形参
实参：函数在调用的时候括号里传入的值
function sum(x,y){
var sum=x+y
console.log(sum)
}//x,y为形参
console.log(2,3)//2,3为实参
//注意：形参与实参的参数数量可以不一致，但可能实现不了预期效果
arguments：可以获取每个传入的参数值，即实参。它是一个伪数组
function f1(){
console.log(arguments.length)//6
console.log(arguments)//[1,2,3,4,5,6,collee:f...]
}
f1(1,2,3,4,5,6)
回调函数：即当函数作为参数使用时，这个函数就称为回调函数
function f1(fn){
fn()//将函数作为变量、参数传进去，之后被调用
}
function f2(){这是一个将要被作为参数的函数}
f1(f2)//传入f2函数，此时f2函数作为参数传入，被称为回调函数。传入的是函数的代码，不需要加括号；如果加括号了就是传入了函数的返回值
全局变量：全局变量可以在页面的任何位置使用。函数域外定义的变量都是全局变量。如果页面不关闭就不会释放，会占用内存。
局部变量：在函数内部定义的变量。
隐式全局变量：声明的变量没有var，区别在于没有var的变量会被轻易删除
全局作用域：全局变量的使用范围
局部作用域：局部变量的使用范围
块级作用域：一对大括号，里面的变量只能在里边使用，js只有函数内是块级作用域
作用域链：函数会在内部逐级调用；在内部的变量会在当前作用域找，如果找不到，会依次往外围作用域寻找
var num=10//---0级作用域
function f1=(){
var num=20//---1级作用域
function f2(){
//var num=30---2级作用域
console.log(num)//由于2级作用域的num被注释了，就往上找，在1级作用域中找到num，输出20
}
f2()//在f1中调用其内部的f2，f2才会被执行
}
f1()//调用f1，会循循往里深入
提前解析代码。它可以把变量的声明提前，提前到当前所在作用域的最上面，即函数内的变量只会提前到函数内部的最上边；函数的声明也会被提前，提前到当前所在作用域的最上面
//原本形式
console.log(num)//输出undefined
var num=10
//预解析后
var num//预解析会把声明放在上边
console.log(num)//输出undefined
num=10
//原本形式
function f1(){
console.log(num)//undefined
var num=10
}
//预解析后
function f1(){
var num
console.log(num)//undefined
num=10
}
console.log(num)//报错，因为变量只是提前到当前作用域最上边，外部没有声明
//原本形式
f1()
function f1(){}
//预解析后
function f1(){}
f1()
var a=25;
function f1(){
alert(a)//输出undefined。
var a=10
}
//预解析会把a的声明提前，即alert上边是var a
//在这里a由于没有值，可以理解为a被赋值undefined
//所以函数能在内部找到a变量，
//所以函数不会根据作用域链的原理往外找外边的a变量，而只是输出内部的undefined
f1()
console.log(a)//报错
console.log(b)//9
console.log(c)//9
function f1(){
var a=b=c=9;
console.log(a)//9
console.log(b)//9
console.log(c)//9
}
//解析：首先函数预解析后会被提前，函数可调用。其次，函数内部的变量声明会被提前，即:
//var a;a=9;b=9;c=9;
//在这里，a是局部变量，而b和c是隐式全局变量，故b和c外部可以访问，而外部访问局部变量a的时候会报错
f1()
var f1=function(){
console.log(a);
var a=10;
}
//结果：报错，函数不能调用
//解析：注意，这里的f1是一个变量，首先变量的声明会被提前，即：
//var f1；
//f1()
//在这里，f1不是一个函数，而是一个没有被赋值的变量 ，所以f1无法调用，报错
return后面的值称之为返回值，注意，当你需要返回值，调用函数之后需要定义一个变量接收；return后面的代码不会执行
function getSum(x,y){
return x+y
}
//定义变量接收返回值
var result=getSum(x+y)
console.log(result)
function getSum(x,y){
return x+y
}
//这里表示先调用再输出返回值
console.log(getSum(x,y))
函数作为返回值使用
function f1(){
return function(){我是返回的匿名函数}
}
var f2=f1()//在这里，f2就成了f1返回的那个匿名函数，即f2=function(){我是返回的匿名函数}
f2()//调用返回的匿名函数
//求n-m内数字的和
function getSum(n,m){
var sum=0;
for(var i=n;i<m;i++){
sum+=i;
}
return sum
}
console.log(getSum(1,100))
//求圆的面积
function getS(r){
return Math.PI*r*r;
}
console.log(getSum(10))
//求一组数字的和
function getSum(array){
var sum =0;
for(var i-0;i<array.length;i++){
sum+=array[i]
}
return sum
}
console.log(getSum([1,2,3,4]))
函数部分的内容会在这篇文章有更多细节的展开
js不是面向对象的语言，但是可以模拟面向对象的思想，js是一门基于对象的语言，即本身有对象可以直接用。引入 ：
instanceof ，判断变量是否属于某类型,语法：变量instanceof类型的名字
xiaoming instanceof Object——判断小明是否属于对象
调用系统的构造函数
//语法
var 变量名=new Object()
//实例化对象
var xiaoming=new Object()
//添加属性
xiaoming.age=18
xiaoming.sex="男"
//添加方法(行为)
xiaoming.sleep=function(){
console.log("我天天睡懒觉")
}
//获取与调用
console.log(xiaoming.name)
xiaoming.sleep()
//在当前的对象的方法中，可以使用this关键字代表当前对象
xiaoming.sleep=function(){console.log("我天天睡懒觉，我是"+xiaoming.name)}
xiaoming.sleep=function(){console.log("我天天睡懒觉，我是"+this.name)}
工厂模式
需求：第一种方法无法一次性创建多个对象，我该怎么做？
解决：把创建对象的代码封装在一个函数中
function createPerson(){
var person=new Object();//---1.创建对象
person.name="小明";//---2.添加属性
person.age=18;
person.sayHi=function(){
alert(‘你好，我叫‘+this.name+"我今年"+this.age+"岁")
}//---3.添加方法
return person//---4.返回对象
}
//使用：创建人的对象
var person1=createPerson()
person1.sayHi()//---此时就能使用封装函数内定义的属性和方法
需求：上面的方法只能创建相同的对象，但我要不同的，我该怎么办？
解决：传入变量
function createPerson(name,age){
var person=new Object();
person.name=name;//在这里，左边的person.name是个属性，右边name是个变量
person.age=age;
person.sayHi=function(){
alert(‘你好，我叫‘+this.name+"我今年"+this.age+"岁")
}
return person
}
var person1=createPerson("小明",18)
自定义构造函数
需求：不能分辨出对象到底属于哪个对象类型？怎么办？
解决：自定义构造函数。
function Person(){
this.name="小明";
this.age=18;
this.sayHi=function(){
alert(‘你好，我叫‘+this.name+"我今年"+this.age+"岁")
}
}
var person1=new Person()
console.log(person1 instanceof Person)//true
function Person(name,age){
this.name=name;
this.age=age;
this.sayHi=function(){
alert(‘你好，我叫‘+this.name+"我今年"+this.age+"岁")
}
}
var person1=new Person("小明",18)
console.log(person1 instanceof Person)//true
与工厂模式对比，少了new Object()和return；属性与方法直接用this而不用person。构造函数与函数的区别：名字上，构造函数首字母要大写；调用上，没有区别
自定义构造函数创建对象做了四件事：
1.开辟空间，储存创建的新对象
2.把this设置为当前对象
3.设置对象的属性和方法的值
4.返回创建后的新对象
字面量的方式
//1.原始写法
var person={}//创建了一个空对象
person.name="小明";
person.age=18;
person.sayHi=function(){
alert(‘你好，我叫‘+this.name)
}
//2.优化后的写法
var person={
name:"小明",
age:20,
sayHi:function(){
alert(‘你好，我叫‘+this.name)
}
}
缺陷：它是一次性的对象，无法轻易改值，只能在对象内部更改。即对象一开始就被写死
obj.name 、obj.name="小明"obj["name"]、obj["name"]="小明"json也是一个对象，一般json格式的数据无论是键还是值都是用双引号括起来的
- 基本类型（值类型）：number，string，boolean
值类型的值在栈中储存。值在栈。- 复杂类型（引用类型）：object
引用类型的值在栈和堆中储存。对象在堆，引用（地址）在栈
值类型作为函数的参数时，传递值
function f1(x){
x=100;
}
var num=10
f1(num)
console.log(num)//10
//解析：f1调用相当于在栈创建了一个内存=> x=100
//函数内部可以这样理解：var x;x=100 传进来的参数10自动化为变量x
引用类型作为函数的参数时，传递的是地址
var obj={name="小明"}
function f2(obj2){
obj2.name="小红"
}
console.log(obj.name)//"小明"
f2(obj);
console.log(obj.name)//"小红"
//解析：f2调用相当于传递obj的地址，进而在堆的找到地址上进行修改。这里obj和obj2指向的是同个地址
JS包括三种对象
- 内置对象——js系统自带的对象
- 自定义对象——自定义构造函数创建的对象
- 浏览器对象——BOM
- 实例对象：通过构造函数创建出来，实例化的对象
- 静态对象：不需要创建，静态方法直接通过这个对象的名字调用
Math，它具有数学常数和函数的属性和方法。它不是一个构造器，不能直接new实例化。
//属性
Math.E//自然对数的底数e==>2.718281828459045
Math.PI//圆周率
//方法
Math.abs(-2)//取绝对值==>2
Math.ceil(10.1)//向上取整==>11
Math.floor(10.1)//向下取整==>10
Math.max(1,2,3,4)//获取最大值==>4
Math.random() //返回一个0-1的浮点
[案例1]在1-10中获取随机数
parseInt(Math.random()*10+1)
[案例2]自定义构造函数，实现取最大值
function MyMax(){
this.getMax=function(){
var max=arguments[0];
for(var i=0;i<arguments.length;i++){
if(max<arguments[i]){
max=arguments[i]
}
}
return max
}
}
var mt=new MyMath();
var result=mt.getMax(10,20,30)
console.log(result)//30
[案例3]随机生成一个十六进制的颜色值
function getColor(){
var str="#"
//十六进制的值的数组
var arr=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"]
//生成十六进制的6个索引
for(var i=0;i<6;i++){
//随机生成arr数组的索引，以根据索引获得里面的值
var num=parseInt(Math.random()*16);
//拼接字符串
str+=arr[num]
}
return str
}
Date，创建date实例来处理时间和日期，可以new实例化
//与Math不同，Date首先要实例化
var dt=new Date()//表示实例化时刻的日期和时间。已自动转换成字符串类型
dt.toDateString()//英文格式==>Fri Jul 31 2020
dt.toLocaleDateString()//数字格式==>2020/7/31
dt.toTimeString()//小时分钟秒==>16:16:12 GMT+0800 (中国标准时间)
dt.toLocaleTimeString()//小时分钟秒==>下午4:16:12
dt.getFullYear()//获取年份
dt.getMonth()+1//获取月份，这里的月份是从0开始算的
dt.getDate()//获取日期
dt.getHours()//获取小时
dt.getMinutes()//获取分钟
dt.getSeconds()//获取秒
dt.getDay()//获取星期，0指的是星期日
[案例1]封装函数——格式化后的指定格式的日期和时间
指定的格式：2020年7月31日 16:16:12
function getDate(dt){
var year=dt.getFullYear();
var month=dt.getMonth()+1;
var day=dt.getDate();
var hour=dt.getHours();
var minute=dt.getMinutes();
var second=dt.getSeconds();
month=month<10?"0"+month:month;
day=day<10?"0"+day:day;
hour=hour<10?"0"+hour:hour;
minute=minute<10?"0"+minute:minute;
second=second<10?"0"+second:second;
return year+"年"+month+"月"+day+"日"+hour+"："+minute+"："+second
}
//调用
getDate(new Date())
String，全局对象，用于字符串或一个字符串序列的构造函数
string：字符串类型——值类型
var str="hello"
String：字符串类型——引用类型var str=new String("hello")
一个字符串既是值类型又是引用类型。以上两种方式声明的字符串都可以被认为是实例化的一个对象，即都可以使用内置的方法。区别在于是否使用了内置方法和属性。
字符串特性：不可变性，即字符串原来的值不可改变
//这里的改变是因为重新赋值了
var str="hello"//这里在堆生成了地址1
str="hi"//这里在堆生成了地址2，原来的地址1没改
console.log(str)//hi 这里是因为地址的指向发生改变
//不可变性
var str="hello"
str[1]="w"//字符串可以通过索引访问某个值，但是只可以访问不能修改，即只读
console.log(str)//hello
属性与方法
string.length
返回字符串的长度
var str="hello"
str.length//5
chartAt()
输入索引，找到该索引位置的值。语法：str.chartAt(索引)。如果指定的索引超出了该范围，则返回一个空字符串
var str="hello"
str.charAt(2)//l
concat()
合并字符串，并返回一个新的字符串。语法：str.concat(字符串1，字符串2，字符串3...)
var str="hello"
str.cancat(‘my‘,‘name‘,‘is‘,‘xiaoming‘)//hellomynameisxiaoming
indexOf()
返回字符串中第一次出现指定值的索引，只找一个。语法：str.indexOf(指定值，从哪里开始找)，第二个参数默认是0；如果未找到该值，则返回 -1；区分大小写
//通常用法
var str="Blue Whale"
str.indexOf("Blue") // 返回 0
str.indexOf("Blute") // 返回 -1
str.indexOf("Whale", 5) // 返回 5
str.indexOf("blue") // 返回 -1
//检测是否存在某字符串
str.indexOf(‘Blue‘) !== -1 // true
str.indexOf(‘Bloe‘) !== -1 // false
includes()
判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false。语法：str.includes(要找的字符,从哪开始])。区分大小写
var str= "Blue Whale"
str.includes(‘blue‘); // false
match()
返回一个字符串匹配正则表达式的的结果。语法：str.match(regexp)
正则表达式相关知识请看这篇文章
var str="中国移动10086；中国联通10010"
var array=str.match(/\d{5}/)//这样只能匹配一个
var array=str.match(/\d{5}/g)//全局匹配 ["10086","10010"]
replace()
如果与正则表达式相匹配，就将这个字符串替换成自己想要的
语法：str.replace(regexp|substr, newSubStr|function)
var str="小明睡懒觉了"
str=str.replace(/睡懒觉/,"起床")
console.log(str)//小明起床了
slice()
输入开始索引与结束索引，截取其中间的字符。语法：str.slice(开始索引，结束索引)，从第一个索引开始，到第二个索引前结束。
var str = ‘The morning is upon us.‘
str.slice(1, 8)//he morn
substr()
从指定位置开始，直到满足指定字符数后结束，返回字符串。语法：str.substr(开始索引，字符数)，如果后面没有参数，则返回从索引开始到结束的字符串。
var str = "abcdefghij";
str.substr(1,2); // bc
str.substr(1); // bcdefghij
toLocaleLowerCase()
把字符串转换为小写的格式。
var str=HELLO
str.toLocaleLowerCase()//hello
toLocaleUpperCase()
把字符串转换为大写的格式。
var str=hello
str.toLocaleLowerCase()//HELLO
split()
用特定分隔符认定字符串中需要分割的位置，分割成数组。语法：str.split(分隔符，切割后留下的个数)
var str = "Hello World. How are you doing?";
str.split(" ", 3)//["Hello", "World.", "How"]
String.fromCharCode()
返回使用指定的Unicode值的序列创建的字符串。静态方法，即不能通过实例化直接调用，而是直接用大写的String调用
String.fromCharCode(65)//A 如果输入多个则返回拼接后的字符串
[案例]找到这个字符串中索引a出现的位置
var str="asjdhqohkjasekcaxa"
var index=0//开始的位置
var key="a"//要找的字符串
while((index=str.indexOf(key,index))!=-1){
console.log(index)
index+=key.length
}
forEach()
遍历数组。对数组的每个元素执行一次给定的函数，不会改变原数组。这个函数不能终止循环
语法：arr.forEach(item,(index)=>{操作})
const arr1= [‘a‘, ‘b‘, ‘c‘];
arr.forEach(item => console.log(item));
const arr2 = [1, 4, 9, 16];
arr.forEach(item=> item * 2);//打印输出：[1, 4, 9, 16]
map()
把每个元素进行处理后返回一个新数组
语法：arr.map(item,(index)=>{处理})
const arr = [1, 4, 9, 16];
arr.map(item=> item * 2);//打印输出：[2, 8, 18, 32]
every()
测试数组内的所有元素是否都能通过某个指定函数,返回一个布尔值。可提前终止
语法：arr.every(item,(index)=>{测试})
const arr = [1, 30, 39, 29, 10, 13];
arr.every(item=>item<40))//打印输出：true 即所有元素满足小于40
some()
测试数组是否至少有1个元素通过了测试，返回一个布尔值。可提前终止
语法：arr.some(item,(index)=>{测试})
const arr = [1, 2, 3, 4, 5];
arr.some(item=>item%2===0)//打印输出：true 即至少有一个元素可被2整除
find()
返回数组中通过测试的第一个元素值。否则返回 undefined。可提前终止
语法：arr.find(item,(index)=>{测试})
const arr = [5, 12, 8, 130, 44];
arr.find(item=>item>10)//12 即12是第一个大于10的元素，返回
findIndex()
返回数组中通过测试的第一个元素的索引。否则返回-1。可提前终止
语法：arr.findIndex(item,(index)=>{测试})
const arr = [5, 12, 8, 130, 44];
arr.findIndex(item=>item>13)//打印输出：3 即第一个满足测试的元素的索引是3
cancat()
合并两个或多个数组,返回一个新数组。
语法：旧数组.cancat(数组1，数组2...)
const arr1 = [‘a‘, ‘b‘, ‘c‘];
const arr2 = [‘d‘, ‘e‘, ‘f‘];
arr1.concat(arr2)//打印输出：["a", "b", "c", "d", "e", "f"]
filter()
创建一个新数组, 里面是通过测试的所有元素。
语法:arr.filter(item,(index)=>{测试})
const arr = [‘spray‘, ‘limit‘, ‘elite‘, ‘exuberant‘, ‘destruction‘, ‘present‘];
arr.filter(item=>item.length>6)//打印输出：["exuberant", "destruction", "present"]
push()
将元素添加到数组的末尾，并返回该数组的新长度。改变原有
语法：arr.push(元素1,元素2...)
const animals = [‘pigs‘, ‘goats‘, ‘sheep‘];
animals.push(‘cows‘)//打印输出：4
animals//打印输出：["pigs", "goats", "sheep", "cows"]
unshift()
将元素添加到数组的开头，返回该数组的新长度,改变原有
语法：arr.unshift(元素1,元素2...)
const arr = [1, 2, 3];
arr.unshift(4, 5)//打印输出：5
arr//打印输出：[4, 5, 1, 2, 3]
pop()
从数组中删除最后一个元素，返回该元素的值,更改了数组的长度。
语法：arr.pop()
const plants = [‘broccoli‘, ‘cauliflower‘, ‘cabbage‘, ‘kale‘, ‘tomato‘];
plants.pop()//打印输出："tomato"
plants//打印输出：["broccoli", "cauliflower", "cabbage", "kale"]
shift()
从数组中删除第一个元素，返回该元素的值。更改了数组的长度。
语法：arr.shift()
const arr = [1, 2, 3];
arr.shift()//打印输出：1
arr//打印输出：[2, 3]
indexOf()
找给定元素的索引，返回。如果不存在，则返回-1。
语法：arr.indexOf(要找的元素，从哪里开始)
const beasts = [‘ant‘, ‘bison‘, ‘camel‘, ‘duck‘, ‘bison‘];
beasts.indexOf(‘bison‘)//打印输出：1
join()
用一个指定符号把数组元素连接起来，返回连接好的字符串
语法：arr.join("指定符号")
const arr = [‘Fire‘, ‘Air‘, ‘Water‘];
arr,join(‘-‘)//打印输出："Fire-Air-Water"
reverse()
颠倒数组元素的位置
语法：arr.reverse()
const arr = [‘one‘, ‘two‘, ‘three‘];
arr.reverse();//打印输出：["three", "two", "one"]
sort()
对数组的元素进行排序，并返回数组,改变了。按照转换为的字符串的各个字符的Unicode位点进行排序。
语法：arr.sort()，arr.sort(比较函数)
const months = [‘March‘, ‘Jan‘, ‘Feb‘, ‘Dec‘];
months.sort();//打印输出：["Dec", "Feb", "Jan", "March"]
var numbers = [4, 2, 5, 1, 3];
sort((a, b) => a - b); //打印输出：[1, 2, 3, 4, 5]
slice()
从开始位置到结束位置抽取新数组,不包括结束位置的元素
语法：arr.slice(开始索引，结束索引)
const animals = [‘ant‘, ‘bison‘, ‘camel‘, ‘duck‘, ‘elephant‘];
animals.slice(2)//打印输出：["camel", "duck", "elephant"]
animals.slice(2, 4)//打印输出：["camel", "duck"]
splice()
删除、替换或添加元素来修改数组,以数组形式返回被修改(替换)的内容。改变原数组。
语法：arr.splice(开始位置，要移除的个数，要添加（替换）的元素)
//删除
var myFish = [‘angel‘, ‘clown‘, ‘drum‘, ‘mandarin‘, ‘sturgeon‘];
myFish.splice(3, 1)//从第三位删除一个元素。打印输出：["mandarin"]
myFish//打印输出：["angel", "clown", "drum", "sturgeon"]
//替换
var myFish = [‘angel‘, ‘clown‘, ‘drum‘, ‘sturgeon‘];
myFish.splice(2, 1, "trumpet");//从第二个元素开始删除一个插入一个，即替换第三个元素。打印输出：["drum"]
myFish//打印输出：["angel", "clown", "trumpet", "sturgeon"]
//添加或插入
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
myFish.splice(2, 0, "drum");//从第二个位置添加元素“drum”。打印输出:[]
myFish//打印输出：["angel", "clown", "drum", "mandarin", "sturgeon"]
Array.isArray()
静态方法，判断传递的值是否为一个数组
Array.isArray([1, 2, 3]); // true
Array.isArray({foo: 123}); // false
普通变量不能直接调用属性或者方法 对象可以直接调用属性和方法
本身是基本类型，但是在执行代码的过程中，如这种类型的变量调用了属性或者是方法，那么这种类型就不再是基本类型了，而是基本包装类型。这个变量也不是普通的变量了，而是基本包装类型对象
var num=Number("10")//类型转换
var num=new Number//基本包装类型
parseInt（）：转为整数parseFloat（）：转小数Number()：转数字，更为严格.toString()：转字符串，如果变量有意义使用String（）：转字符串，没有意义时转换，即可以是未声明或null等Boolean（） ：转布尔值。0|字符串没有内容|null|undefined等没有意义的为false从上到下，从左到右
if if-else if-else if switch-case
if(条件){事件1}else{事件2}
//三元表达式可达到同等效果
//解释：判断条件的结果是true还是false，如果是true执行事件1，如果是2执行事件2，最后把结果赋值给变量
var a=条件?事件1:事件2
if(条件1){事件1}else if(条件2){事件2}else{事件3}
//else if可无限添加
switch(变量){
case 值1:事件1:
break;
case 值2:事件2:
break;
case 值3:事件3:
break;
default:事件4
}
//获取变量的值，与case的值依次比较，如果一样则执行事件并且跳出整个语句。若前面都不相同，执行default事件。
//变量与case值比较时，是严格模式，即“===”
//若事件重复，值可集合在一起，在这个集合中，前面的事件和break可以省略，只保留最后一个即可
while do-while for for-in
while(循环条件){
循环体；
计数器++
}
//判断循环条件是否为true，为true时执行，先循环体再计数器
//计算1-100所有值的和
var sum=0
var i=0
while(i<100){
sum+=;
i++;
}
//解析：第一次进入循环，sum=0，i=1；
//第二次进入循环,sum=0+1，i=2;
//第三次进入循环，sum=1+2，i=3
do{
循环体
}while(循环条件)
//先执行循环体，再判断条件，成立时继续执行，否则跳出
for(变量；判断；计数器){
循环体
}
//例子
for(var i=0;i<10;i++){
执行事件
}
break：循环中如果碰到则会跳出当前循环
continue：不再执行其后面的事件，直接进入下一次循环
原文：https://www.cnblogs.com/sanhuamao/p/13595523.html