JavaScript笔记

第一章-JavaScript的基本使用

一、输出语句

1.浏览器中弹出警告框

 alert('未满18岁禁止访问')

2.控制台输出信息

console.log("111");

3.网页中输出内容

document.write("加油！")

二、输入语句

1.在网页弹出一个输入框

 prompt("请输入姓名")

2.在网页弹出一个确认框

 confirm("你真的满18岁了吗")

三、引入方式

1.行内式

弊：行内式可读性差，编译大量代码时，阅读不便

<button onclick="window.alert('别点了')">请点我</button>

2.嵌入式（内嵌式）

弊：容易混淆代码

 <script>window.alert("内部样式")</script>

3.外链式

利：便于修改和维护，且可以利用浏览器缓存提高速度

 <script src="./03-JS代码引入方式.html"></script>

第二章-JavaScript的基本语法

一、变量

1.变量的声明与赋值

变量的声明与赋值可分为先声明再赋值和声明变量的同时并赋值两种

前者事例如下：

var boy;
boy = "温伦耀";
console.log(boy);

后者事例如下：

var age = 16;
console.log(age);

2.let声明变量

let是ES6新引入的关键字，用来替代var关键字；使用var声明变量，可以多次赋值，但是结果为最后一次赋值；let不允许在一个代码块里面有变量和它取一样的名字，但允许修改同一个变量值

let girl = "1";
console.log(girl);

注：一个{}就代表一个代码块

{let girl = "a";}

3.const声明变量

let和var声明的变量可以改变，const声明的变量不可以改变，所以const用来声明常量

const a = 1
console.log(a);

注：const必须在声明的时候就赋值

const  b = 1

4.声明变量的区别

(1).初始化不同

使用var和let声明变量时可以先不初始化，而使用const声明变量时必须初始化

(2).重复声明不同

使用var和let声明的变量可以多次被修，其值只与最近一次赋值一致，
而使用const声明的变量，在整个运行过程中不能修改初值

(3).对块级作用域的支持不同

使用一个花括号括起来的代码称为一个代码块所谓块级作用域，
就是指变量起作用的范围是当代码块，离开当前代码块，变量就失效了，
使用var声明的变量支持全局作用域，使用let和const声明的变量支持块级作用域

二、数据类型

1.数据类型分类

数据类型可分为简单数据类型和复杂数据类型两种，前者存储在栈内存中，后者存储在堆内存中，地址存储在堆内存中

2.基本数据类型

(1).Boolean-布尔型

let flag = true;
console.log(falg);

注：带引号的不是布尔型，是字符串

let flag = "ture" ；
console.log(flag);

(2).Number-数字型

let age = 18;
let date = "0306";
console.log(age);
console.log(date);

console.log(Number.MAX_VALUE);//最大值
console.log(Number.MAX_VALUE*2);//无穷大（Infinity）

注1：NaN (Not a Number)NaN也属于数字类型

 var a = 3-"b";
 console.log(a);

注2：isNaN判断是否是一个非数字,如果是数字类型则为false，如果是非数字类型则为true

console.log(isNaN(a));//true
console.log(isNaN(111));//false
console.log(isNaN("abc"));//true
console.log(isNaN(Infinity));//false
console.log(isNaN("false"));//true

(3).string-字符串

let demo1 = "字符串";
let demo2 = "字符串";
let demo3 = '字符串';
console.log("111\'222")

(4).undefined-未定义

表示声明的变量还未赋值

 let grade;
 console.log(grade);

(5).null-空

var a = null;
console.log(a);

3.数据类型检测

(1).typeof()

console.log(typeof("123"));//string
console.log(typeof(false));//boolean
console.log(typeof("false"));//string
console.log(typeof(NaN));//number
console.log(typeof(Infinity));//number
console.log(typeof(undefined));//undefined
console.log(typeof(null));//object
console.log(typeof('aaa'*2));//Number
console.log(typeof(2-"true"));//Number

4.数据类型转化

(1).将数据类型转化为布尔类型

字符串类型和数字类型都会转化为布尔类型的true；空字符串转化为布尔类型的false，空格字符串转为true；数字0转为布尔类型的false

var a = Boolean("a")
console.log(a);//true
console.log(Boolean(123));//true
console.log((Boolean("")));//false
console.log(Boolean(" "));//true
console.log(Boolean(0));//false
console.log(Boolean(NaN));//false
console.log(Boolean(undefined));//false
console.log(Boolean(null));//false

(2).将数据转化为字符串类型

使用String()或toString()进行转换

let num = 1;
console.log(num);//数字类型的1
let num2 = String(num);
console.log(num2);//字符串类型的1

(3).将数据转化为数字型数据

Number()用于将数据转化为数字型数据

console.log(Number(123));//123
console.log(Number("123"));//123
console.log(Number(""));//0
console.log(Number(" "));//0
console.log(Number(null));//0
console.log(Number(undefined));//NaN
console.log(Number(false));//0
console.log(Number(true));//1
console.log(Number("true"));//NaN
console.log(Number("123.1"));//123.1
console.log(Number("123.a"));//NaN

三、运算符

1.算数运算符

(1).加法运算

let a = 10;
let b = 20;
//ab值同下
console.log(a+b);//30
        

(2).减法运算

let c = b-a;
console.log(c);//10

(3).乘法运算

console.log(c*b);//200

(4).除法运算

 b = b / a
 console.log(b);//2

(5).取模运算（取余数）

console.log(26%5);//1

(6).幂运算

console.log(2 ** 3);//8

(7).自增运算

m = 5;
n = ++m;
console.log(m);//6
console.log(n);//6

m = 5;
n = m++;
console.log(m);//6
console.log(n);//5

var x = 1; y = 2;
console.log(++x);//2
console.log(x);//2
console.log(y++);//2
console.log(y);//3

(8).自减运算

 q = 2;
 p = --q;
 console.log(q);//1
 console.log(p);//1

 q = 2;
 p = q--;

 console.log(q);//1
 console.log(p);//2

 var d = 10; s = 20;
 console.log(++d);//11
 console.log(d);//11
 console.log(d--);//11
 console.log(d);//10

2.字符串运算符及隐形转换 

隐式转换：当两个数据类型不同时，JS会按照既定的规则进行转换
字符串运算符：加号遇上字符串，做拼接使用

 console.log(1 + 1);//2
 console.log(1 + null);//1
 console.log(1 + true);//2
 console.log(1 + false);//1

 console.log("12" - 0);//12
 console.log(undefined * null);//NaN
 console.log(Infinity ++);//Infinity

 console.log(1 + "1");//11
 console.log(1 + "null");//1null
 console.log(null + "undefined");//nullundefined

 var name = "张三";
 var agr = 18;
 console.log(name+"的年龄是："+age);

3.赋值运算符

//赋值
let a = 10;
let b = 20;
let c = a + b;

//加等于/加并赋值 +=
a += b;//a = a + b
console.log(a);//30
console.log(b);//20

//减等于/减并赋值 -=
a -= b;//a = a - b
console.log(a);//10
console.log(b);//20

a *= b;
a /= b;
a %= b;
a **= b;

4.比较运算符

(1). != 不等于

 console.log(4 != 5);//true
 console.log(4 != 4);//false

(2). !== 不全等

console.log("5" !== 5);//true

(3). == 等于

 console.log(4 == "4");//true

(4). === 全等于

console.log(4 === "4");//false

 注：==和!==在比较不用数据类型时，会将比较的数据转化为相同的类型数据，===和！====则不会进行数据类型的转化

5.逻辑运算符

(1).逻辑与运算符 

&&——假则假

console.log(true && true);//true
console.log(false && true);//false
console.log(true && false);//false
console.log(false && false);//false

(2).逻辑或运算符

||——真则真

console.log(true || true);//true
console.log(true || false);//true
console.log(false || true);//true
console.log(false || false);//false 

6.三元运算符

形式：表达式 ？ 表达式1 ：表达式2

如果表达式的值为true，则返回表达式1的执行结果

如果表达式的值为false，则返回表达式2的执行结果

var age = prompt("请输入您的年龄")
console.log(age);
var res = age >= 18 ? "你已经是一名优秀的成年人了"  : "你还是一个宝宝"
document.write(res)

7.运算符优先级

小括号>一元运算符 > 逻辑运算符 （逻辑与>逻辑或）> 赋值运算符

let a = 3 > 5 && 2 < 7 && 3 == 4;
console.log(a);//flase

let b = 3 > 5 || 2 < 7 && 3 == 4;
console.log(b);//false

let c = 2 === "2";
console.log(c);//true

let d = !c && ( b || a);
console.log(d);//false

四、流程控制

1.选择结构

(1).if语句(单分支)

结构：if(条件表达式) {代码段}

let age1 = prompt("请输入你的年龄")
         if (age >= 18) {
            document.write("你可以进入本网站")
        }

(2).if ... else语句(双分支)

结构：if(条件表达式) {代码段}else{代码段2}

let age2 = prompt("请输入你的年龄")
if (age2 >= 18) {
    document.write("你可以进入本网站")
}else {
    document.write("非法访问")
}

(3).if ... else if ...else(多分支)

结构：if(条件表达式1){
                  条件表达式1的结果
           }else if(条件表达式2){
                  条件表达式2的结果
           }else}else{
                   除去12的结果
           }

 let num = prompt("请输入你的成绩"
 if(num == 100){
     document.write("获得奖学金")
 }else if(num >=80 && num <=90){
     document.write("成绩优秀")
 }else if(num >=60 && num<80){
     document.write("成绩合格")
 }else if(num >=20 && num<40){
     document.write("挂科")
 }else{
     document.write("枪毙")
}

(4).switch语句

结构：switch(表达式1){
                case 值1:
                代码段;
                break;
                case 值2:
                代码段
                break;
                ...
                default;
                代码段n;
          }

let subject = +prompt('请输入你想要选择的专业:1-区块链专业;2-UI专业;3-土木专业;4-农林专业')
console.log(subject);
switch(subject){
    case 1:
    document.write('恭喜你选择了最牛逼的专业')
    break;
    case 2:
    document.write('恭喜你选择了UI专业')
    break;
    case 3:
    document.write('恭喜你选择了土木专业')
    break;
    case 4:
    document.write('恭喜你选择了农林专业')
    break;
    default:
    document.write('请输入你的专业')
}

2.循环结构

(1).for语句

结构：for(初始化变量;条件表达式;操作表达式){循环体}

for(var i = 1;i<=100;i++){
  console.log(i);
}

(2).while语句

结构：while(条件表达式){循环体}

var i = 1;
while(i<=100){
  console.log(i);
  i++
}

(3).do...while语句

结构：do{循环体}while(表达式）

与while的区别：while语句先判断条件表达式的值，再根据条件表达式的值决定是否执行循环体；do...whlie语句会无条件执行1次循环体，然后再判断条件表达式的值，再根据判断的值绝对是否继续进行循环

var i = 1;
do{
 console.log(i);
 i++
} while(i<=100)

3.跳转语句

(1).break

for(var i = 1 ;i <= 5 ;i++){
    if (i == 3){
        console.log("你吃到了新鲜的答辩");
        break;//跳出整个循环
    }
    console.log("你吃到了第"+i+"坨答辩");
}

(2).continue

for(var n = 1; n <= 5; n++){
    if(n == 3){
        console.log("吃到了新鲜的答辩");
        continue;//
    }
    console.log("你吃到了第"+n+"坨答辩");
}

二者区别：break语句会立即跳出整个循环，也就是循环结束；continue语句用来立即跳出本次循环，也就是跳过continue语句后面的代码继续下一次循环

4.循环嵌套

var str = '';
for(var a = 1; a <= 5; a++){
    for(var b =1; b <= a; b++){
        document.write("❤")
    }
    document.write("<br/>")
}

第三章-数组 

一、初识数组

数组是一种复杂数据类型，用于将一组数组集合在一起，通过一个变量就可以访问一组数据，数组之间通过逗号分隔，数组中的"索引/下标"，是从0开始计算的 

(1).声明数组

let class02 = ["tom",'lily','tony']

(2).打印数组

console.log(class02);

(3).打印数组长度

console.log(class02.length);//3

打印数组中下注为X的元素，例：

console.log(class02[0]);//'tom'
console.log(class02[1]);//'lily'

注 ：数组可以是任何类型的元素，例如字符串、数字、数组

let arr1 = [1,2,3,4,5,6]
let arr2 = ['string',NaN,null,undefined,arr1]
console.log(arr2);

二、创建数组

(1).以New Array () 方式创建数组

 var arr = new Array();
 console.log(arr);
 var arr = new Array(5);
 console.log(arr);
 var arr = new Array("tom","tony","bob")
 console.log(arr);

(2).使用数组字面量创建数组

var mood = ["sad","happy", , , , , "happy"]
console.log(mood.length);
console.log(mood[7]);

三、数组的基本操作

(1).获取元素长度

数组名.lenght

(2).修改数组长度

数组名.lenght = number，例：

var arr = [0,1,2,3]
console.log(arr.length);//4
arr.length = 5
console.log(arr);//[0,1,2,3,empty]
arr.length = 3
console.log(arr);//[0,1,2]

(3).添加数组元素

arr[4] = 3
console.log(arr);//[0,1,2,empty,3]

(4).修改数组元素

arr[0]= 1
console.log(arr);//[1,1,2,empty,3]

(5).删除数组元素

delete 数组名[index] 删除数组中的某个元素值，例：

delete arr[1];
console.log(arr);//[1,empty,2,empty,3]

(6).遍历数组

let arr1 = [10,20,30,40,50,60]
var sum = 0;
for (var i = 0; i < arr1.length; i++){
    sum += arr1[i]
    // arr[0] 10   sum+10=0+10=10
    // arr[1] 20   sum+20=10+20=30
    // arr[2] 30   sum+30=30+30=60
    // arr[3] 40
    // arr[4] 50
    // arr[5] 60
    // arr[6] 70
}
console.log(sum);//210

(7).新增数组元素

push在数组后添加元素

let arr3 = [1,2,3,4]
arr3.push(5,6)
console.log(arr3);//[1,2,3,4,5]

unshift在数组后添加元素

arr3.unshift(-2,-1,0)
console.log(arr3);//[-2,-1,0,1,2,3,4,5,6]

四、二维数组

二维数组指的是数组元素的值是一个一维数组，例：

var arr = [80,100,75]
var arr1 = [
    [80,100,75]
    [90,67,66]
    [99,87,85]
]

访问二维数组

 console.log(arr1[0]);//[80,100,75]
 console.log(arr1[0][0]);//80

//遍历二维数组arr1
for(var i = 0; i<arr1.length; i++){
    //遍历数组arr的元素
    for(var j = 0; j<arr[i].length; j++){
        console.log(arr1[i][j]);
    }
}

 二维数组倒置

var arr1 = [
    [1,2,3]
    [4,5,6]
    [7,8,9]
]
var arr2 = []

//遍历原数组的行
for (var i = 0; arr1[0].length; i++){
    //根据原数组的行设置原数组的列
    arr2[i] = [];
    //遍历原数组的列
    for (var j = 0;j < arr1.length; j++){
        //颠倒位置
        ar2[i][j] = arr1[j][i]//j是原数组的列，i是原数组的行
    }
}
console.log(arr2);

第四章-函数

一、初识函数

函数定义：函数用于封装完成一段特定功能的代码,相当于将一条或者多条语句组成的代码块包裹起来,用户在使用时只需要关心参数和返回值，就能完成特定的功能，而不用了解具体的实现

 自定义函数：提高代码的复用性，降低程序维护的难度

1.内置函数

 console.log(isNaN("number"));//true
 console.log(parseInt('15.99'));//15

2.无参函数

 function demo () {
 console.log("我是一个大帅哥");
 }
 // 使用函数
 demo()
 demo()

// function指这是一个函数语句
// name是函数名
// params是函数参数
// {}内放函数的具体功能

3.有参函数

function sum (a,b) {
    console.log(a + b);
}
sum(1,2)
sum(88888,99999)

4.函数值的返回 

函数的返回值是指函数在调用后获得的数据在定义函数时，可以为函数指定一个返回值，函数的返回值可以是任意类型的数据

function total01 (price,num) {
    all = price * num
    return all
}
console.log(total01(9999,12));

二、函数内外变量的作用域

1.变量

(1).全局变量

在函数体外声明的变量或者在函数体内省略var关键字的声明!

var a = 10
function demo () {
     console.log(a);//a为全局变量，在函数体内可以被访问
}
demo()
console.log(a);//a为全局变量，在函数体外也可以被访问

(2).局部变量

在函数体内利用var关键字声明的变量

function demo1 () {
    var b = 10//b是var关键字声明的变量，为局部变量
    console.log(b);//函数内部定义的局部变量b，可以在函数内部被访问
    c = 20;//c是省略var关键字的声明，为全局变量
    console.log(c);//全局变量c，可以在函数内部被访问
}
demo1()//10
console.log(b);//b is notdefined 不可以在函数外访问局部变量b
console.log(c);

(3).块级变量

在es6标准中，新增的let关键字声明的变量为块级变量，注：一个花括号为一个块级

if (true) {
    let sex = '男'//let声明的变量sex为块级变量
    console.log(sex);//块级变量sex可以在{}内部被访问
}
console.log(sex);//块级变量sex不可以在{}内部被访问

for(let i = 0; i < 5; i++){
    console.log("循环内部"+i);
}
console.log("循环外部"+i);//i is not defined

2.作用域

(1).全局作用域

被全局变量所拥有：在{}外声明的变量

(2).局部作用域

被局部变量所拥有：在函数内定义的变量

(3).块级作用域

被块级变量所拥有：在分支语句或者循环大括号中定义的变量

三、函数进阶

1.匿名函数

var fn = function (num1,num2) {
    console.log(num1,num2);
}
fn(1,2)
var fn1 = function (num1,num2) {
    return num1 + num2;
}
console.log(fn2(num1,num2));

2.箭头函数

var fn3 = (num1,num2) => {
    console.log(num1,num2);
}
fn3(1,2)
// 函数体只有一句话时，可以省略花括号
var fn4 = (num1,num2) => console.log(num1,num2);
fn4(1,2)
// 当函数只有一句代码，并且函数的执行结果就是函数的返回值时，可以省略函数的花括号和return关键字
var fn5 = (num1,num2) => num1 + num2;
console.log(fn5(num1,num2));
// 当函数参数只有一个时，可以省略函数外部的小括号和函数的花括号
var fn6 = num1 => num1 + num1;
console.log(fn5(num1,num2));

四、回调函数

 // 函数fn作为参数传递给参数cal，然后在函数cal中调用函数fn，此时，fn就是回调函数
 function cal (num1,num2,fn) {
     return fn (num1,num2)
 }
 console.log(cal(10,20,function(a,b) {
     return a + b
 }));//30

五、定时器函数

(1).setInterval()

Interval:间隔、间隙，时间间隔一到，代码就会在指定毫秒后执行一次

setInterval(function(){
    console.log("1");
},9999)

(2).setTimeout()

该方法用来指某个函数或某段代码在多少毫秒后执行,setTimeout指定的代码，必须等同步代码执行完毕后执行

setTimeout(function(){
    console.log("2");
},9999)
console.log(3);

六、函数嵌套与作用域链

嵌套函数：

var i = 10;
function fn1 () {
    var i = 20;
    function fn2 () {
        function fn3 () {
            console.log(i);
        }
        fn3()
    }
    fn2()
}
fn1()

注： 函数变量访问规则：就近原则；当在一个作用域中访问变量时，首先看当前作用域有没有声明；如果有则访问，没有则往上作用域查找，直到达到顶峰作用域没有时，程序报错

七、闭包函数

闭包：闭包是一种代码形式，内部函数访问外部函数的局部变量；闭包的作用：解决变量污染的问题，让变量被函数保护起来

// 例：js函数a中有一个函数b，函数b翻完了函数a里面定义的局部变量，此时就产生了闭包
//    变量所在的函数就是闭包函数，即a为闭包函数
function outer () {
    // 外部函数定义的局部变量
    let n = 10;
    // 内部函数
    function inner () {
        // 内部函数要访问外部函数定义的局部变量
        console.log(n);
    }
    inner()
}
outer()

let count = 0
setInterval(function(){
    console.log(count++);
},500)
// 在这段代码中，count是一个常用的变量名
// 为了避免和其他位置的代码发生冲突，可以使用一个函数将上面的代码包裹起来

八、网页计算器

实例：

<P>整数1: <input type="text" id="num1"></P>
<p>整数2: <input type="text" id="num2"></p>
<p>
    <input type="button" value="相加" onclick="cal(add)">
    <input type="button" value="相减" onclick="cal(add)">
    <input type="button" value="相乘" onclick="cal(add)">
    <input type="button" value="相除" onclick="cal(add)">
</p>
<p>结果: <input type="text" id="result"></p>
<script>
    function add(num1,num2){
        return num1+num2
    }
    function sub(num1,num2){
        return num1-num2
    }
    function mul(num1,num2){
        return num1*num2
    }
    function div(num1,num2){
        if(num2 === 0){
            alert("除数不能为0")
            return "";
        }
        return num1/num2
    }
    function cal(func){
        var num1 = document.getElementById("num1").value
        var num1 = document.getElementById("num2").value
        var num1 = document.getElementById("result").value
        result.value = func(num1,num2)
    }

九、递归函数

递归函数是一个函数间接或直接地调用自身

function getSum3(n){
    if(n == 1){
        return 1;
    }
    // 当前数组+比自己小1的数字
    return + getSum3(n-1)
}
console.log(getSum3(2));

例：斐波那契数列(每一项等于前两项之和)

// 求斐波那契数列(递归写法)
function getValue1(n){
    // 设置终点
    if(n===1 || n===2){
        return 1
    }
    // 未到终点
    return getValue1(n-1) + getValue1(n-2)
}
console.log(getValue1(10));

第五章-对象

一.介绍对象

对象是一种复杂数据类型；复杂数据类型的内容存储在堆内存中，地址存储在栈内存中；对象作用：以键值的形式存储在多个数据

例：存储一个人的信息(姓名、年龄、性别)

// 1.使用简单数据类型
let name = "李三";
let age = 1;
let sex = "男";
// 好处：阅读性高，弊端：冗余

// 2.数组
let peopel = ["李三",1,"男"]
// 好处：一个变量存储多个数据，弊端：阅读型不高

// 3.对象
let obj = {
    name : "李三" ,
    age : 1 ,
    sex : "男" ,
    sayHi:function(){
        console.log("1111");
    }
}

// 3.1对象查询
console.log(obj);
console.log(obj.name);
console.log(obj.sayHi);
// 3.2对象新增

obj.bf="三五"
console.log(obj);

// 3.3对象修改
obj.bf="万一"
console.log(obj);
// 对于对象的属性，如果有这个属性是修改属性值，如果没有则是新增

// 3.4对象删除
delete obj.age
console.log(obj);

// 3.5对象遍历
// 遍历数组：for (let i=0; i<arr.length; i++) {}
// 遍历对象：for-in循环: for(let key in 对象名) {对象名 [key]}
let score = {
    math:99,
    history:80,
    geology:70,
    ehglish:60
}
for(let key in score){
    console.log(key);// 打印属性名
    console.log(score[key]);// 打印属性值
}

二.Math对象

1.圆周率

console.log(Math.PI);
const c = 2*Math.PI*r
console.log(c);

2.绝对值

console.log(Math.abs(-1.5));

3.最大/最小值

console.log(Math.max(1,2,3,4));
console.log(Math.min(1,2,3,4));

4.幂运算

console.log(Math.pow(2,10));

5.四舍五入

console.log(Math.round(-3.5));//-3
console.log(Math.round(-3.6));//-4

6.向上取整

console.log(Math.ceil(-3.1));//-3

7.向下取整

console.log(Math.floor(-1.8));//-2

8.生成0-1之间的随机小数

console.log(Math.random());

9.生成0-100的随机整数

console.log(Math.round(Math.random()*100));

三.Date对象

时间戳：从某年某月某日某点某分某秒到现在的毫秒数

以下三种写法都会得到时间戳：

console.log(Date.now());
console.log(+new Date);
console.log(new Date().getTime());

// 获取年份
console.log(new Date().getFullYear());
// 获取月份
console.log(new Date().getMonth());//范围是0-11
// 获取日期
console.log(new Date().getDate());//范围是1-31
// 获取星期
console.log(new Date().getDay());//范围是0-6，星期天是0
// 获取小时
console.log(new Date().getHours());
// 获取分钟
console.log(new Date().getMinutes());

实例1：设置出生年月日

// 获取内置Date对象
var date = new Date();
// 设置年份
date.setFullYear(2004)
date.setMonth(10)
date.setDate(12)
// 获取年份
var year = date.getFullYear()
var month = date.getMonth()
var day = date.getDate()
// 打印年份
console.log(year);
console.log(month);
console.log(day);
document.write("出生于"+year+"年"+month+"月"+day+"日")

 实例2：在页面中显示“今天是2024年5月22日，星期三”

alert("今天是"+new Date().getFullYear()+"年"+new Date().getMonth()+"月"+new Date().getDate()+"日，星期"+new Date().getDay())

四.Array对象

1.push()

在数组末尾添加一个元素

course.push("1")
console.log(course);

2.unshift()

在数组开头添加一个元素

course.unshift("2")
console.log(course);

3.pop()

删除数组中最后一个元素

course.pop()
console.log(course);

4.shift()

删除数组第一个元素

course.shift()
console.log(course);

5.splice(start, deleteCount)

var arr = [1,2,3,4,5,6,7]
arr.splice(3,2)// 从下标为3的数字(4)开始，删掉后面两个数字
console.log(arr);// [1,2,3,6,7]

arr.splice(4,0,9999)// 从下标为4的数字(6)开始，往后面添加一些元素
console.log(arr);// [1,2,3,6,9999,7]

6.reverse()

颠倒数组中元素的索引

var arr1 = [1,2,3,4,5,6,7]
arr1.reverse()
console.log(arr1);

7.sort()

(1).升序排序

 var arr2 = [19,45,29,0,18,73]
 arr2.sort(function(a,b) {
     return a-b
 })
 console.log(arr2);

(2).降序排序

var arr3 = [19,45,29,0,18,73]
arr3.sort(function(a,b) {
    return b-a
})
console.log(arr3);

8.获取数组元素索引的方法

(1).indexOf(eklement)

返回指定元素在数组中第一次出现的索引，不存在则返回-1

var color = ["green","pink","red"]
console.log(color.indexOf("red"));//2
console.log(color.indexOf("white"));//-1

(2).lastIndexOf(element)

返回指定元素在数组中最后一次出现的索引，不存在则返回-1

var color = ["green","pink","red"]
console.log(color.lastIndexOf("red"));//2

9.将数组转化为字符串

(1).toSring()

将数组转化为字符串，用逗号分隔数组中的每个元素

console.log(color.toString());//green,pink,red

(2).join()

将数组中的所有元素连接成一个字符串，默认用逗号分隔开，可指定分隔符

console.log(color.join());//green,pink,red
console.log(color.join("-"));//green-pink-red
console.log(color.join("/"));//green/pink/red

10.数组类型检测

var obj = {
    name:'张三'
}
console.log(Array.isArray(arr));//true
console.log(Array.isArray(obj));//false

五.String对象

// 创建字符串对象
var str = new String("apple")
console.log(str);

// 访问字符串长度
console.log(str.length);

// 数据类型检测
console.log(typeof(str));//objec
var str1 = "banana"
console.log(typeof(str1));

// 根据字符串返回索引
// indexOf(element):返回字符串中第一次出现的索引，不存在则返回-1
// lastIndexOf(element):返回字符串中最后一次出现的索引，不存在则返回-1
var str = "helloworld"
console.log(str.indexOf("o"));
console.log(str.lastIndexOf("o"));

// 根据索引返回字符串
// chatAt()
console.log(str.charAt(7));

// 字符串截取
// slice(start)
console.log(str.slice(5));

// slice(start.end) 从start的下标截取到end的下标
console.log(str.slice(1,4));
console.log(str);

// 字符串连接
// concat()
var str1 = "hello"
var str2 = ",world"
console.log(str.concat(str2));

// 大小写转换
// toUpperCase()转化为大写
// tolowerCase()转化为小写
console.log(str1.toUpperCase());
console.log("HELLO",tolowerCase());

// 替换
// replace(str1,str2)
console.log(str);
console.log(str.replace("world","JS"));

// 字符串分隔
// split(分隔符)
console.log(str.split());
console.log(str.split(""));
console.log(str.split("O"));