js基础
js中的原始数据
类型有六种：number , string , boolean , null, undefined（未定义）, object.
var num;
console.log(num);//undefined;变量声明了，但是没有初始化（或是函数没有明确返回值，但被接收了）
var num;
console.log(num);//NaN;(不是一个数字)
//如果一个变量的结果是undefined，和一个数字进行运算，结果是NaN,也没有意义。使用typeof获取变量的数据类型
//typeof的使用方法(两种)
1.typeof 变量名
2.typeof(变量名)
var num = 11;
var str = "hello";
var bool = true;
var undef;
var nu = null;
var object = new Object();
console.log(typeof num);//number
console.log(typeof(str));//string
console.log(typeof(bool));//boolean
console.log(typeof(undef));//undefined
console.log(typeof(nu));//object
console.log(typeof(object));//object
//null是表示这个对象的值为空，所以是属于object类型。js中的进制表示
var num1 = 10;//十进制的10
console.log(num1);//10
var num2 = 010;//八进制的10
console.log(num2);//8
var num3 = 0x10;//十六进制的10
console.log(num3);//16js中的类型转换
//2.其他类型转数字类型。
console.log(parseInt("12"));//12
console.log(parseInt("12a"));//12
console.log(parseInt("a12"));//NaN
console.log(parseInt("12.98"));//12
console.log(parseInt("13.12"));//13
console.log(parseFloat("12"));//12
console.log(parseFloat("12a"));//12
console.log(parseFloat("a12"));//NaN
console.log(parseFloat("12.98"));//12.98
console.log(parseFloat("13.12"));//13.12
console.log(Number("12"));//12
console.log(Number("12a"));//NaN
console.log(Number("a12"));//NaN
console.log(Number("12.98"));//12.98
console.log(Number("13.12"));//13.12
//其他类型转数字类型---三种方式
1.使用parseInt()转整数
2.使用parseFloat()转小数
3.使用Number()严格转数字
//2.其他类型转字符串类型
//1. toString();
//2. String(var)
//如果变量有意义，使用toString()方式
//如果变量没有意义，使用String()方式。
var num = 10;
console.log(num.toString());
var num2 = 11;
console.log(String(num));
//*********3.其他类型转布尔类型**********
//Boolean(值)
console.log(Boolean(1));//true
console.log(Boolean(0));//false
console.log(Boolean(11));//true
console.log(Boolean(-10));//true
console.log(Boolean("哈哈"));//true
console.log(Boolean(""));//false
console.log(Boolean(null));//false
console.log(Boolean(undefined));//falsenumber类型
//数字类型有范围，最大值和最小值
console.log(Number.MAX_VALUE);//1.7976931348623157e+308
console.log(Number.MIN_VALUE);//5e-324
//注意：不要拿小数去验证小数。
//注意：不要用NaN验证是不是NaN。
如何验证结果是不是NaN，使用isNaN()。
判断结果不是一个数字，可以使用isNaN(变量)。
数字类型-->number类型。（无论是整数还是小数都是number类型）
进制的表示：
十进制：10
八进制：010
十六进制：0x001string类型
//字符串
//获得字符串的长度使用 str.length()
var str = "what are you neng sha ne ";
console.log(str.length);
var str1 = "1234567jiangxishengyichunshiycu";
console.log(str1.length);
转移字符：\\ \t \" 等
//字符串的拼接
var str1 = "您好";
var str2 = "我好";
console.log(str1+str2);
//只要有一个是字符串，其他是数字，那么结果也是拼接，不是相加。
var num1 = "10";
var num2 = 5;
console.log(num1-num2);//5
var num1 = 10;
var num2 = "5";
console.log(num1 - num2);//5
//如果有一个是字符串，另一个不是字符串，使用减号，此时会发生计算。
（浏览器会将字符串转换为数字类型，再进行计算。称为“隐式转换”）。布尔类型
布尔类型有两个值：true和false。
console.log(Boolean(1));//true
console.log(Boolean(0));//false
console.log(Boolean(-10));//true
console.log(Boolean(10));//true
变量值如果想为null，必须手动设置。表达式
算数操作符： + - * / %
算数运算表达式：有算数运算符连接起来的表达式
一元运算符：这个操作符只需要一个操作数就可以运算的符号。++ --
二元运算符：这个操作符需要两个操作数就可以运算的符号
三元运算符 ？：
复合运算符：+= -= *= /= %=
var num = 10;
num += 10;
复合运算表达式：由复合运算符连接起来的表达式
关系运算符：>, <, >=, <=, ==(不严格等), ===（严格等）, !=, !==
关系运算表达式：由关系元素符连接起来的表达式（结果是boolean类型）
逻辑运算符：&&（逻辑与） ||（逻辑或） ！（逻辑非）
逻辑运算表达式：有逻辑运算符连接而成的表达式。
//字面量：把一个值直接赋值给一个变量。
//声明变量并初始化。
var num = 10;
var flag = true;
var str = "haha";
分支结构
/**
*
* 页面弹框输入年龄，判断是否为成年人，如果成年输出可以看电影了，如果不成年输出回家写作业
*
*/
var age = prompt("请输入您的年龄！");
if (isNaN(age)) {
console.log("您输入的不是一个数字！");
} else {
if (age > 18) {
console.log("可以看电影了！");
} else {
console.log("看什么看，回家写作业去！");
}
}
switch-case
注意问题：
1.default后面的break可以省略。
2.default也可以省略。
3.case后面的break也可以省略，但是需要注意可能会出现问题。(没有break不会自动停止，只有遇到break或右大括号才会停止。)。
4.比较时相当于===。既要比较值，也要比较类型。循环结构
/**
* 写一个九九乘法表
*/
document.write("<table border='1' cellpadding='0' cellspacing='0'>");
for(var i = 1; i <=9; i++){
document.write("<tr>")
for(var j = 1; j <= i; j++){
document.write("<td>"+j+"*"+i+"="+(i*j)+"</td>");
}
document.write("</tr>")
}
document.write("</table>");数组
数组：一组数有序的数据。
数组的作用：可以一次性存储多个数据。
数组的定义：
1.通过构造函数创建数组
var 数组名 = new Array();
var arr = new Array();
注意：数组的名字如果直接输出，那么直接就可以把数组中的数据显示出来，如果没有数据，就看不到数据
var arr = new Array(长度);//如果数组中没有数据，但是定义了长度，数组中的每个值都是
undefined;
var arr = new Array(10,20,30,40,50);//给数组赋值。
//如果通过构造函数创建数组时，括号中只有一个数字，则该数字是指明数组的长度，如果数组中有多个数据，则是
//给数组进行赋值，数组的长度就是数据的个数
2.通过字面量的方式创建数组
var 数组名 = [];//空数组
var arr = [10,20,30,40];
//arr.length获得数组的长度。
JS数组中存储的数据类型可以不一致。（通常存储的数据类型是一样的）
注意：Js中的数组的长度是可以改变的。排序
var arr = [10,2,6,24,72,3,2,6,4,72,45,21,2345,65,32];
//以下是选择排序法
for(var i = 0; i < arr.length-1; i++){
for(var j = i+1; j < arr.length; j++){
if(arr[i]>arr[j]){
var temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
//使用冒泡排序
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;
}
}
}
console.log(arr);
全局变量与局部变量
JS中没有块级作用域一说。在块级作用域{}中定义的变量在块级作用域以外也可以访问。
全局变量：生命的变量时使用var生命的，那么这个变量就是全局变量，全局变量可以在页面的任何位置使用。
(除了函数以外，其他的任何位置定义的变量都是全局变量)
全局变量，如果页面不关闭，那么就不会释放，就会占空间，消耗内存。
局部变量：在函数内部定义的变量是局部变量，外面不能使用。
隐式全局变量：不使用var定义的变量。
全局变量不可以被删除，隐式全局变量可以被删除。（使用var定义的变量不可以被删除，不适用var定义的变量可以被删除）
全局作用域：全局变量的使用范围
局部作用域：局部变量的使用范围
变量的查找范围是从小到大的。预解析
预解析：提交解析代码；
预解析做了什么事：
1.把变量的声明提前了，提前到了当前所在的作用域的最上面。
2.函数的声明也会被提前了，提前到当前所在的作用域的最上面。
预解析中，变量的提升，只会在当前的作用域中提升，提升到当前的作用域的最上面
函数中的变量，只会提前到函数的作用域中的最前面，不会出去
预解析的过程：
1.把变量的声明提升到当前作用域的最前面，只会提升声明，不会提升赋值。
2.把函数的声明提升到当前作用域的最前面，只会提升声明，不会提升赋值。
3.先提升var，再提升function
函数
1、函数的定义：
function 函数名字（）{
函数体；
}
2、函数的调用
函数名字（）；
3、 函数需要先定义再使用。
函数名需要遵循驼峰命名法。
函数不能重名，否则会被覆盖。（后面的函数会把前面的函数覆盖）
形参的个数可以与实参个数不同。
函数没有明确的返回值，但是被接收了，此时结果为undefined。（没有返回值：函数没有return，或函数有return,但是return后面没有任何内容）；
4、函数的形参定义时是不需要写关键字var。
5、return关键字表示将结果返回。如果只有return，表示结束函数。
如果输出的是函数名而不是函数名()，则输出的是函数的内容（函数代码）。
6、命名函数与匿名函数
命名函数：如果函数有名字，则称为命名函数
匿名函数：如果函数没有名字，则称为匿名函数。
/**
* arguments对象
*/
//函数表达式：把一个函数赋值给一个变量，此时就形成了函数表达式。
function fun(){
var sum = 0;
for(var i = 0; i < arguments.length; i++){
sum += arguments[i];
}
return sum;
}
console.log(fun(1,2,4,5));//12
console.log(fun(1,2,4,5,5,6,6));//29
//注意：
//函数声明
function f1(){
console.log("Hello Java");
}
f1();//Hello JavaScript
function f1(){
console.log("Hello JavaScript");
}
f1();//Hello JavaScript
//函数表达式
var f2 = function (){
console.log("java");
};
f2();//java
f2 = function (){
console.log("JavaScript");
};
f2();//JavaScript
//函数的自调用;（声明的同时，函数直接调用，一次性的）
(function(){
console.log("这是函数的自调用！");
})();arguments对象（伪数组）
/**
* arguments对象
*/
function fun(){
var sum = 0;
for(var i = 0; i < arguments.length; i++){
sum += arguments[i];
}
return sum;
}
console.log(fun(1,2,4,5));//12
console.log(fun(1,2,4,5,5,6,6));//29
对象
//* 创建对象的三种方式。
//* 1.调用系统的构造函数创建对象。
var obj = new Object();
Object()就是系统的构造函数。
//* 2.自定义构造函数创建对象
//自定义构造函数创建对象
/**
以下代码做的几件事：
var person = new Person("ooyhao",22);
1.在内存中开辟空间，存储创建的新的对象。
2.把this设置为当前的对象
3.设置对象的属性和方法的值
4.把this对象返回
*/
function Person(name,age){
this.name = name;
this.age = age;
this.study = function(){
console.log("学习");
}
}
var person = new Person("ooyhao",22);
person.name = "yanghao";
console.log(person.name);
console.log(person.age);
person.study();
//字面量的方式创建对象（一次性的对象：无法向构造函数那样进行参数传递进行赋值）。
var obj = {
name:"ooyhao",
age:3,
eat:function(){
console.log("没钱吃!");
},
showInfo:function(){
console.log(this.name+","+this.age);
}
};
// obj.name = "yanghao";
console.log(obj.name);
console.log(obj.age);
obj.eat();
obj.showInfo();
Instanceof关键字
如何获取该变量（对象）是不是属于该类型的？
语法：
变量 instanceof 类型的名字。返回布尔类型，true就是这种类型，false就不是这种类型。
this
在当前的对象的方法中，可以使用this关键字代表当前对象。
Js是一门什么样的语言：
1.是一门解释性语言
2.是一门脚本语言
3.是一门弱类型的语言，声明变量都用var
4.是一门基于对象的语言
5.是一门动态类型的语言：
1.代码（变量）只有执行到这个位置的时候，才知道这个变量中到底存储的是什么，如果是对象，就有对象
的属性和方法，如果是变量就是变量的作用、
2.对象没有什么，只要点了，通过点语法，那么就可以为对象添加属性和方法。 设置对象的属性或方法的另一种方式
/**
* 设置和获取属性的另一种方式
*/
function Person(name, age){
this.name = name;
this.age = age;
this.play = function(){
console.log(this.name+"喜欢玩游戏");
}
}
var person = new Person("小明",22);
person["name"] = "小红";
console.log(person["name"]);
console.log(person["age"]);
person["play"]();JSON格式的数据
JSON格式的数据：一般都是成对的，是键值对。
JSON格式的数据实际上就是格式化后的一组字符串的数据
json也是一个对象，数据都是成对的，一般json格式的数据无论是键还是值都是用双引号括起来的。
var json = {
"name":"ooyhao",
"age":"12"
};
//使用for-in 循环遍历对象
var json = {
"name":"ooyhao",
"age":"22",
"sex":"男"
};
//使用for-in循环遍历json对象。
for(var key in json){
//key 是一个变量，这个变量中存储的是该对象的所有的属性的名字
console.log(json[key]);
}简单类型和复杂数据类型
值类型的值在哪一块空间中存储？栈中存储。
引用类型的值在哪一块空间中存储？栈（地址）和堆（对象）中存储。
值类型之间的传递，传递的是值。
引用类型之间的传递，传递的是地址（引用）Math对象
Math 是一个内置对象，它具有数学常数和函数的属性和方法，不是一个函数对象。
描述：与其他全局对象不同的是，Math不是一个构造器，Math的所有属性和方法都是静态的。
Math.PI
Math.E
Math.abs()函数的行为
传入一个非数字形式的字符串或者 undefined/empty 变量，将返回 NaN。传入 null 将返回 0。
Math.abs('-1'); // 1
Math.abs(-2); // 2
Math.abs(null); // 0
Math.abs("string"); // NaN
Math.abs(); // NaN
例子：使用 Math.ceil
下例展示了 Math.ceil() 的使用：向上取整。
Math.ceil(.95); // 1
Math.ceil(4); // 4
Math.ceil(7.004); // 8
Math.ceil(-0.95); // -0
Math.ceil(-4); // -4
Math.ceil(-7.004); // -7
Math.floor
描述
由于 floor 是 Math 的一个静态方法，你总是应该像这样使用它 Math.floor()，而不是作为你创建的一个Math对象的一种方法（Math不是一个构造函数）。
例子：使用 Math.floor
Math.floor( 45.95);
// 45
Math.floor( 45.05);
// 45
Math.floor( 4 );
// 4
Math.floor(-45.05);
// -46
Math.floor(-45.95);
// -46
Math.max();一组数中的最大值
Math.max(10, 20); // 20
Math.min();一组数中的最小值
Math.min(10, 20); // 10
Math.pow()
function raisePower(x,y) {
return Math.pow(x,y)
}
如果 x 是 7 ，且 y 是 2，则 raisePower 函数返回 49 （7 的 2 次幂）。
Math.sqrt 求一个数的平方根
Math.sqrt(9); // 3
Math.sqrt(2); // 1.414213562373095
Math.sqrt(1); // 1
Math.sqrt(0); // 0
Math.sqrt(-1); // NaN
Math.random()
函数返回一个浮点, 伪随机数在范围[0，1)，也就是说，从0（包括0）往上，但是不包括1（排除1），然后您可以缩放到所需的范围。实现将初始种子选择到随机数生成算法;它不能被用户选择或重置。他不能被用户选择或重置。
console.log(Math.random()); //0.6185734075381502
/**
* 使用Math对象随机产生一个十六进制的颜色值
*/
function getColor(){
var color = "#"
var num = ["0","1","2","3","4","5","6","7","8","9",
"a","b","c","d","e","f"];
for(var i = 0; i < 6; i++){
var randomNum = parseInt(Math.random()*16);
color += num[randomNum];
}
return color;
}
console.log(getColor());
window.onload = function(){
document.getElementById("dv").style.backgroundColor = getColor();
}
Date对象
/**
* 创建Date对象
*/
var date1 = new Date();
console.log(date1);
var date2 = new Date(1996,03,24);//创建的对象是四月
console.log(date2);
var date3 = new Date("1996-03-24");
console.log(date3);
var date4 = new Date("1996/03/24");
console.log(date4);
console.log(Date.now());//返回当前时间的毫秒值。
//如果浏览器不支持H5，则使用以下方式
var now = + new Date(); //调用Date对象的valueOf();
console.log(now);
var date = new Date();
console.log(date.getYear());
console.log(date.getFullYear());
console.log(date.getMonth());//获取月份，从0开始。
console.log(date.getDate());
console.log(date.getHours());
console.log(date.getMinutes());
console.log(date.getSeconds());
console.log(date.getDay());//获取星期，从0开始。
console.log(date.toDateString());//Sun Jul 08 2018
console.log(date.toLocaleDateString());//2018/7/8
console.log(date.toTimeString());//19:58:48 GMT+0800 (中国标准时间)
console.log(date.toLocaleTimeString());//下午7:58:48
//格式化后的指定格式的日期和时间
function getCurrentDate(date){
var week = ["日","一","二","三","四","五","六"];
var year = date.getFullYear();
var month = date.getMonth()+1;
month = month<=9 ? "0"+month:month;
var day = date.getDate();
day = day <=9 ? "0"+day : day;
var hours = date.getHours();
hours = hours <=9 ? "0"+hours : hours;
var minutes = date.getMinutes();
minutes = minutes <=9 ? "0"+minutes : minutes;
var seconds = date.getSeconds();
seconds = seconds <=9 ? "0"+seconds : seconds;
var weekDay = week[date.getDay()];
return year+"年"
+month+"月"
+day+"日 "
+hours+":"
+minutes+":"
+seconds+" "
+"星期"+weekDay;
}
String对象
String 是一个对象。
字符串可以看成是字符组成的数组，但是js中是没有字符的。
在js中可以使用单引号或双引号括起来。
字符串的特性：
1.不可变性（字符串的值是不可以改变的）字符串的值之所以看起来是改变的，那是因为指向改变了，并不是真的值改变了。
String的属性和方法-->详解和实例
/**
* String对象
*/
var str = " hello ";
var strObj = new String(" hello ");
console.log(typeof str);//string
console.log(typeof(strObj));//object
var string = "what are you doing ?";
//==========属性
//获得字符串长度
console.log("length:"+string.length);//20
//==========方法
//去除首尾的空白符
console.log("trim:"+str.trim());//hello
//获取指定位置上的字符
console.log("charAt:"+string.charAt(1));//h
//获取指定位置上的字符所对应的编码
console.log("charCodeAt:"+string.charCodeAt(1));//104
//连接两个字符串
console.log("concat:"+string.concat("Test"));//what are you doing ?Test
//判断字符串是否包含另一个字符串
console.log("includes:"+string.includes("you"));//true
//判断字符串是否以另一个字符串结尾
console.log("endsWith:"+string.endsWith("?"));//true
console.log("startsWith:"+string.startsWith("what"));//true
//返回指定字符串在该字符串的指定位置开始，第一次出现的位置，无则返回-1
console.log("indexOf:"+string.indexOf("o"));//10
console.log("indexOf:"+string.indexOf("A"));//-1
//返回指定字符串在该字符串的指定位置开始，最后一次出现的位置，无则返回-1
console.log("lastIndexOf:"+string.lastIndexOf('o'));//14
console.log("lastIndexOf:"+string.lastIndexOf('A'));//-1
//匹配正则表达式
console.log("123456abcdefg".match(/^[a-z0-9_-]{6,18}$/));
//格式化数据
console.log("\u1E9B\u0323".normalize("NFC"));
console.log("\u1E9B\u0323".normalize("NFD"));
console.log("\u1E9B\u0323".normalize('NFKC'));
//使用指定字符串将该字符串填充到指定长度
console.log('abc'.padEnd(10)); // "abc "
console.log('abc'.padEnd(10, "foo")); // "abcfoofoof"
console.log('abc'.padEnd(6, "123456")); // "abc123"
console.log('abc'.padEnd(1));// "abc"
//使用指定字符串将该字符串填充到指定长度
console.log('abc'.padStart(10)); // " abc"
console.log('abc'.padStart(10, "foo")); // "foofoofabc"
console.log('abc'.padStart(6,"123465")); // "123abc"
console.log('abc'.padStart(8, "0")); // "00000abc"
console.log('abc'.padStart(1)); // "abc"
//将字符串进行重复N遍
console.log(string.repeat(2));//what are you doing ?what are you doing ?
//将字符串中的指定字符串替换成指定字符串
console.log("hello java".replace("java","JavaScript"));//hello JavaScript
//查询指定字符串（或正则表达式）在该字符串中的位置，无则返回-1
console.log("hello JavaScript".search("JavaScript"));//6
var newStr = "I want be better !";
//获取子字符串
console.log(newStr.slice(2,5));//wan
console.log(newStr.slice(2,-2));//want be better
console.log(newStr.slice(2,newStr.length));//want be better !
console.log(newStr.slice(2,newStr.length+1));//want be better !
console.log(newStr.slice(-3));//r !
console.log(newStr.slice(2,-4));//want be bett
var strArr = newStr.split(" ");
for(var i = 0; i < strArr.length; i++){
console.log(strArr[i]);
}
//I
//want
//be
//better
//!
//截取字符串（从下标为2的位置开始，截取5个）
console.log("hello world".substr(2,5));//llo w
//截取字符串（从下标为2的位置开始，截取到下标为5的位置结束，不包括5）
console.log("hello world".substring(2,5));//llo
//根据任何特定于语言环境的案例映射,将制定的字符串的字符全部转化为指定大小写
console.log("HELLO WORLD12".toLocaleLowerCase());//hello world
console.log("hello world12".toLocaleUpperCase());//HELLO WORLD
//将制定的字符串的字符全部转化为指定大小写
console.log("HELLO WORLD12".toLowerCase());//hello world
console.log("hello world12".toUpperCase());//HELLO WORLD
var strObject = new String("hello");
console.log(typeof strObject);//object
console.log(typeof strObject.toString());//string
var newString = " HELLO ";
console.log("-"+newString.trim()+"-");//-HELLO-
console.log("-"+newString.trimEnd()+"-");//- HELLO-
console.log("-"+newString.trimStart()+"-");//-HELLO -
Array对象
var arr = new Array(1,2,3,4);
//.length
//获取数组的长度
console.log(arr.length);
//Array.isArray(对象);
//判断对象是不是数组类型、
var i = 10;
console.log(Array.isArray(i));//false
console.log(i instanceof Array);//false
console.log(Array.isArray(arr));//true
console.log(arr instanceof Array);//true
//.concat():拼接数组,组合成一个新的数组
var arr1 = [1,2,3];
var arr2 = ['a','b','c'];
console.log(arr1.concat(arr2));
console.log(arr1);//[1,2,3]
console.log(arr2);//['a','b','c']
/**
* .every(回调函数):返回值是布尔类型，函数作为参数使用。
* 回调函数：
* ele : 元素的值（可选）
* index ：索引的值（可选）
* c ：谁调用了这个方法，那么c就是谁（可选，一般不使用）
*/
arr.every(function (ele,index,c){
console.log(ele);
return ele > 0;
});
/**
* filter(function(ele,index,thisArg){}):创建一个新数组，过滤出符合要求的元素，将其组成一个新的数组。
* （每一个元素都需要执行一个回调函数）
* 三个参数：
* ele:数组中的每一个元素
* index:数组元素的下标
* thisArg:调用该方法的数组对象
*/
var arrFilter = [20,30,40,50,60,70,80];
var newArrFilter = arrFilter.filter(function(ele,index){
return ele > 30;
});
console.log("filter:"+newArrFilter);
/**
*
* .push(ele...):将一个或多个元素追加到数组的末尾，并返回数组的大小
* .pop():删除并返回最后一个元素
* .shift():删除并返回第一个元素
* .unshift(ele...):将一个或多个元素添加到开头，并返回数组的大小
*/
var arr = [10,20,30,40,50];
//console.log(arr.push(100,200));//7
//console.log(arr);//[10, 20, 30, 40, 50, 100]
//console.log(arr.pop());//50
//console.log(arr);//[10, 20, 30, 40]
//console.log(arr.shift());//10
//console.log(arr);//[20, 30, 40, 50]
console.log(arr.unshift(99));//6
console.log(arr);
/**
*
* .forEach(function(ele,index,array));遍历数组
* 三个参数：
* 1.ele 数组中的每一元素
* 2.index 数组中的元素的下标
* 3.array 使用该方法的数组
* .indexOf(ele): 从左开始查询，返回ele的位置，无则返回-1
* .lastIndexOf(ele):从右边开始查询，返回ele的位置，无则返回-1
* .join(ele);//返回一个字符串，在每一个元素中间插入制定元素，组成一个字符串
* .map(callback(){}):遍历每一个元素，每一个元素都执行一次callback函数。返回一个新数组。
* .reverse():将数组中的元素进行反转。返回反转后的数组。
* .sort(compareFun(ele1,ele2){}):对数组进行排序，compareFun进行排序规则定义
* .slice():截取数组中的一部分，返回截取后的新数组，包左不包右。（浅拷贝）
* .splice(index,num,ele（可选）):从指定位置（index）开始，删除N（num）个元素，
* 将元素ele插入到指定位置（index），一般用于删除数组中的元素或替换元素，或者是插入元素
*
*
*/
var arr = [10,20,30,40,50,20,30,90];
arr.forEach(function (ele,index,array) {
console.log(ele+"-"+index+"-"+array);
});
console.log(arr.indexOf(20));
console.log(arr.indexOf(100));
console.log(arr.lastIndexOf(20));//5
console.log(arr.lastIndexOf(30));//6
console.log(arr.lastIndexOf(200));//-1
var arr1 = ["a","b","c","d"];
var str = arr1.join("|");
console.log(str);//a|b|c|d （字符串）
var arrMap = [1,4,9,16];
var newArr = arrMap.map(Math.sqrt);
console.log(newArr);//[1, 2, 3, 4]
var arr = [10,20,30,40,50];
console.log(arr.reverse());
var arr2 = [1,6,3,3,7,9,0,2];
console.log(arr2.sort());
console.log(arr2.sort(function (ele1,ele2) {
// return ele1 < ele2;//降序
return ele1 > ele2;//升序
}));
var chsArr = ["aa","bb","cc","dd","ee","ff"];
console.log(chsArr.slice(1,4));// ["bb", "cc", "dd"]
// chsArr.splice(2,0,"ooyhao");
// console.log(chsArr);//["aa", "bb", "ooyhao", "cc", "dd", "ee", "ff"]
chsArr.splice(2,2,"yanghao");
console.log(chsArr);//["aa", "bb", "yanghao", "ee", "ff"]基本包装类型
/**
* 普通变量不能直接调用属性和方法
* 对象可以直接调用属性和方法
*
* 基本包装类型：本身是基本类型。但是在执行代码的过程中，如果这种类型的变量调用了属性或方法，
* 那么这种类型就不再是基本类型了，而是基本包装类，这个变量也不是普通的变量了，
* 而是基本包装类型了
*
* */
var num = 10;//基本包装类型
//num.split();//报错
console.log(num.toString());//对象，基本包装类型
var str = "hello";//str 普通变量
var newStr = str.replace("ll","HH");// str 对象，基本包装类型。
console.log(newStr);
var bool = new Boolean(false);//bool是对象
var result = bool && true;
//如果是一个对象&&true，则结果为true，
//如果是true&&对象，则结果是对象
console.log(result);//true
var num1 = 10;//基本类型
var num2 = Number("10");//基本类型（类型转换）
var num3 = new Number("10");//基本包装类型（对象）const,var,let区别
1.const定义的变量不可以修改，而且必须初始化。
2.var定义的变量可以修改，如果不初始化会输出undefined，不会报错。
3.let是块级作用域，函数内部使用let定义后，对函数外部无影响。