javascripts知识点梳理4

javascripts知识点梳理4

-函数

带返回值的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
语法：
function 函数名（）{
    return  需要返回的值；
}
函数调用
函数名（）    //   此时 调用 函数就可以得到   函数体内return  后面的值

注意：retrun 后的代码不被执行
function add(num1，num2){
    //函数体
    return num1 + num2; // 注意：return 后的代码不执行
    alert('我不会被执行，因为前面有 return');
}
var resNum = add(21,6); // 调用函数，传入 两个实参，并通过 resNum 接收函数返回值
alert(resNum);// 27

定义函数有两种方式

函数声明方式

1
2
3
4
// 命名函数   有函数名 为  fn 
function fn() { ....}
// 调用  那个地方调用都可以
fn()

函数表达式方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 这是 函数表达式 写法   匿名函数后面跟分号结束
var  fn =  function () { ....  }；
// 调用的方式  但是这个方式，函数调用必须写到函数体下面
fn();

1. 函数没有名字，我们称为匿名函数
1. 这个fn 里面存储的是一个函数  
3 这个执行的原理 跟我们 学的 变量使用一致的。


有些函数没必要一定给名字， 比如我们 点击某个按钮，就执行一个代码 

    // 点击按钮  就执行一段代码， 没必要给这个函数再命名了。直接跟一个匿名函数就好了
    btn.onclick = function() { ...};

自执行函数

1
2
3
4
匿名函数除了作为参数传递外，也可以作为启动函数，定义后立即自执行
(function () {
  alert('我是匿名函数，被自执行啦~~！');
})();

函数也是一种数据类型

1
2
3
4
function fn() {
            console.log('11');
 }
 console.log(typeof fn) // function

函数可以作为参数

1
2
3
4
5
6
7
8
9
var fn = function() {
     console.log('我是一个函数');
};
 console.log(fn);

function getFn() {
       console.log('我也是一个函数')
}
 console.log(getFn);

函数可以作为返回值

1
2
3
4
5
6
7
8
9
 function fn() {
            return function() {
                console.log('返回函数')
            };
 }
 //fn() 里面保存的是 返回的 匿名函数function() {}
console.log(fn());
// 函数调用          
fn()();

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
求一个数组 [5,2,99,101,67,77] 中的最大数值
//定义一个 获取数组中 最大数 的函数
function getMaxFromArr(numArray){
    var maxNum = 0;
    for(var i =0;i < numArray.length;i++){
        if(numArray[i] > maxNum){
            maxNum = numArray[i];
        }
    }
    return maxNum;
}
//定义一个数值数组
var arrNum = [5,2,99,101,67,77];
//调用函数获取最大值
var maxN = getMaxFromArr(arrNum);
//打印最大值
alert('最大值为：'+ maxN);




翻转数组，返回一个新数组	
function reverseFun(arr) {
   var newArr = [];
     for (var i = 0; i < arr.length; i++) {
         newArr[i] = arr[arr.length - i - 1];
       }
      return newArr;
}
var arr = [1, 4, 2, 8];
var arr1 = ['pink', 'hotpink', 'deeppink'];
console.log(reverseFun(arr));
console.log(reverseFun(arr1));


对数组排序，从小到大 
function sort(array) {
            for (var i = 0; i < array.length - 1; i++) {
                for (var j = 0; j < array.length - i - 1; j++) {
                    if (arr[j] > arr[j + 1]) {
                        var temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            return array;
        }
var arr = [2, 8, 1, 4, 9];
var arr1 = [2, 4, 8];
console.log(sort(arr));
console.log(sort(arr1));



输入一个年份，判断是否是闰年[闰年：能被4整数并且不能被100整数，或者能被400整数]
function isRun(year) {
            var flag = false;
            if (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {
                flag = true;
            }
            return flag;
        }
console.log(isRun(2010));
console.log(isRun(2012));




输入某年某月某日，判断这一天是这一年的第几天？
1. 先计算 输入的当前 月份的天数   
2. 计算加上 前面几个月的总天数
3. 月份不同 1.3 .5 .7 .8 .10 .12 月是 31 天     4, 6, 9, 11 是 30 天       2 月份 闰年是 29 天 否则 28
4. 这个函数 需要 三个参数 分别是 年 月  日

      function isRun(year) {
                var flag = false;
                if (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {
                    flag = true;
                }
                return flag;
            }
            console.log(isRun(1998));
    
            function getDays(year, month, day) {
                // 先计算当前月的 天数
                var days = day;
                // 下面开始 累加 前面几个月的 总天数 
                for (var i = 1; i < month; i++) {
                    // 月份不同  天数不同 我们用 switch
                    switch (i) {
                        case 1:
                        case 3:
                        case 5:
                        case 7:
                        case 8:
                        case 10:
                        case 12:
                            days += 31;
                            break;
                        case 4:
                        case 6:
                        case 9:
                        case 11:
                            days += 30;
                            break;
                        case 2:
                            if (isRun(year)) {
                                days += 29;
                            } else {
                                days += 28;
                            }
                            break;
                    }
                }
                return days;
            }
    
            console.log(getDays(1998, 5, 2));



arguments的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
JavaScript中，arguments对象是比较特别的一个对象，实际上是当前函数的一个内置属性。也就是说所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有的实参。arguments是一个伪数组，因此及可以进行遍历
当我们不确定有多少个参数传递的时候，可以用arguments 来获取

求任意个数的最大值
function maxValue() {
            var max = arguments[0];
            for (var i = 0; i < arguments.length; i++) {
                if (max < arguments[i]) {
                    max = arguments[i];
                }
            }

            return max;
        }
 console.log(maxValue(2, 4, 5, 9));
 console.log(maxValue(12, 4, 9));


求任意个数的和
function sumFun() {
            var sum = 0;
            for (var i = 0; i < arguments.length; i++) {
                sum += arguments[i];
            }
            return sum;
        }
console.log(sumFun(1, 3, 5));
console.log(sumFun(2, 4, 6));

作用域

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
作用域：变量可以起作用的范围 （区域）
3.1全局变量和局部变量

- 全局作用域
  供所有代码执行的环境(整个script标签内部)
- 局部作用域（私有作用域）
  在调用函数的时候，会形成一个执行函数内代码的新环境。
- 全局变量
  - 在全局作用域下声明的变量叫做全局变量（在函数外部定义的变量）
  - 全局变量在代码的任何位置都可以使用
  - 特殊情况， 再函数内 不var 声明 的 变量  也是全局变量 （不建议使用）
- 局部变量
  - 在局部作用域下声明的变量叫做局部变量（在函数内部定义的变量）
  - 局部变量只能在该函数内部使用


var scope = 12; // 全局变量
function demo() {
    var local = 1; // 局部变量
    console.log(scope) // 12
    console.log(local) // 1
}
console.log(scope) // 12
console.log(local) // 报错 local is not defined

作用域链

  • 如果函数中还有函数，那么在这个作用域中就又可以诞生一个作用域。
  • 根据在内部函数可以访问外部函数变量的这种机制，用链式查找决定哪些数据能被内部函数访问。 就称作作用域链。
1
2
3
4
5
6
7
8
9
10
11
12

function f1() {
    function f2() {
    }
}

var num = 456;

function f3() {
    function f4() {    
    }
}

预解析

1
2
3
4
5
6
7
8
9
10
11
12
13
JavaScript代码是由浏览器中的JavaScript解析器来执行的。JavaScript解析器在运行JavaScript代码的时候，分为两步：预解析和代码执行

- 预解析过程
  - JavaScript解析器会在全局环境下查找 var、function关键字，变量只声明不赋值，函数声明加赋值。
  - 预解析只发生在当前作用域下
- 预解析也叫做变量、函数提升
  - 变量提升
    定义变量的时候，变量的声明会被提升到当前作用域的最上面，变量的赋值不会提升。
  - 函数提升
    JavaScript解析器首先会把当前作用域的函数声明提前到整个作用域的最前面

- 执行过程
  - 变量赋值、函数调用、表达式运算等等。

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
// 案例1
var num = 10;
function fn(){
    console.log(num);
    var num = 20;
    console.log(num);
} 
fn();

// 案例2
var num = 10;
fun();
function fun() {
  console.log(num);
  var num = 20;
}


// 案例3
var a = 18;
f1();
function f1() {
  var b = 9;
  console.log(a);
  console.log(b);
  var a = '123';
}


// 案例4
var a = 25;
function abc (){
  alert(a);
  var a = 10;
}
abc();
console.log(a);
function a() {
  console.log('aaaaa');
}
var a = 1;
console.log(a);


// 案例5
f1();
console.log(c);
console.log(b);
console.log(a);
function f1() {
  var a = b = c = 9;
  console.log(a);
  console.log(b);
  console.log(c);
}
解释:  
function f1() {
  var a =9;
b=9;
c=9;
  console.log(a);
  console.log(b);
  console.log(c);
}
f1();
console.log(c);
console.log(b);
console.log(a);



// 练习 1
alert(a)
alert(fn)

var a = 1;
function fn(){ 
    return falss;
};

// 练习2
var a; 
function fn(){
    return false;
}; 

alert(a);
alert(fn);
a = 1; 
function fn(){ 
    return false;
};

// 练习3
alert(a);
var a = 1;
alert(a)
function a(){
    return false;
}



var a = 123;
function test() {
  console.log( a + 2);  //?
  var a = 2;
   console.log( a + 2);  //?
}
test();



function test(f) {
		f(123);
}

test( function(v){
	alert(v + 3);//?
} );

对象

创建对象

对象字面量 方式创建（重点 较为常用） {}
new Object 创建对象

对象调用：

​ 对象.属性名
对象[‘属性名’]
对象.方法名() 

1
2
3
4
5
6
7
- 对象里面的属性调用 :   对象.属性名         这个小点 就理解为 的  
- 对象里面的属性另外调用方式 :   对象['属性名']    注意  方括号里面的属性 必须加 引号   我们后面会用      
- 对象里面的方法调用： 对象.方法名()       注意这个方法名字后面一定加括号

console.log(star.name)  // 调用 名字属性
console.log(star.age)  // 调用 年龄属性
star.sayHi();  // 调用 sayHi 方法   注意，一定不要忘记带后面的括号

自定义构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1. 构造函数用于创建一类对象，首字母要大写。
2. 构造函数要和new一起使用才有意义。

    function Person(name, age, sex) {
         this.name = name;
         this.age = age;
         this.sex = sex;
         this.sayHi = function() {
              alert('我的名字叫：' + this.name + '，年龄：' + this.age + '，性别：' + this.sex);
        }
    }
    var bigbai = new Person('大白', 100, '男');
    var smallbai = new Person('小白', 21, '男');
    console.log(bigbai.name);
    console.log(smallbai.name);

new关键字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function Student(name, age) {
    this.name = name;
    this.age = age;
    this.sayHi = function() {
        alert(this.name + '你好');
    }
}
var lilei = new Student('李雷', 18);
var hanmm = new Student('韩梅梅', 17);
console.log(lilei.name);
lilei.sayHi();

new在执行时会做四件事情

    new会在内存中创建一个新的空对象
    new 会让this指向这个新的对象
    执行构造函数里面的代码  目的：给这个新对象加属性和方法
    new会返回这个新对象 （所以构造函数里面不需要return）

this详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
JavaScript中的this指向问题，有时候会让人难以捉摸，随着学习的深入，我们可以逐渐了解
现在我们需要掌握函数内部的this几个特点
	1. 函数在定义的时候this是不确定的，只有在调用的时候才可以确定
	2. 一般函数直接执行，内部this指向全局window
	3. 函数作为一个对象的方法，被该对象所调用，那么this指向的是该对象（谁调用指向谁）
	4. 构造函数中的this  对象的实例  




// 1. 普通函数
function fn() {
    console.log(this); // this 指向 window
 }
fn();
 // 2 对象方法
var obj = {
    name: 'zs',
    dance: function() {
         console.log(this);
         that = this;
}
}
obj.dance(); //  this 指向 obj  
console.log(that === obj); // true
// 3 构造函数
function Fn() {
    this.age = '18';
    console.log(this)
    self = this;
}
var demo = new Fn(); // this  指向 demo
console.log(self === demo); // true

删除对象的属性和方法

1
2
3
4
5
6
7
8
9
我们使用 delete 可以删除 某个 属性  
var obj = {
            name: 'andy',
            age: 18,
            sex: '男'
        }
console.log(obj.name); // andy
delete obj.name;
console.log(obj.name); // undefined

高级技巧_对象覆盖写法

Object.assign(Obj1,Obj2) 用第二个对象覆盖第一个对象

高级技巧_判断是数组还是对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  // console.log(a.consturctor);
    // function fn(){
        var a = [1,2,3,4,5,6];
        var c = {
            name:'zs',
            age:18
        }
        var b = c.constructor
  
    console.log(b);


 var a = [1,2,3,4,5,6];
var b = a.constructor === Array ? [] :{};
console.log(b);

因为  数组  和   对象都属于函数  函数就有原型对象
利用原型对象里的constructor  属性指向

for in 遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

for...in 语句用于对数组或者对象的属性进行循环操作。
for (变量 in 对象名字) {
    在此执行代码
}
- 这个变量是自定义 符合命名规范  但是一般我们 都写为 k  或则  key
- 后面的是对象 可以  数组     因为 数组也属于对象 



 for in 遍历 数组
var arr = ['pink', 'hotpink', 'deeppink'];
for (var k in arr) {
   console.log(k); // 这里的k 是 数组的索引号
   console.log(arr[k]); // 这里的arr[k] 是 数组的值
}

for in 遍历 对象
var obj = {
     name: 'andy',
     age: 18,
     sex: '男'
}
console.log(obj.length); // undefined
for (var k in obj) {
    console.log(k); // 这里的k 是属性名
    console.log(obj[k]); // 这里的 obj[k] 是属性值
}
再对象里面， 这里的k  是 属性名

for in 遍历

for in 遍历 数组

1
2
3
4
5
var arr = ['pink', 'hotpink', 'deeppink'];
for (var k in arr) {
   console.log(k); // 这里的k 是 数组的索引号
   console.log(arr[k]); // 这里的arr[k] 是 数组的值
}

for in 遍历 对象

1
2
3
4
5
6
7
8
9
10
11
var obj = {
     name: 'andy',
     age: 18,
     sex: '男'
}
console.log(obj.length); // undefined
for (var k in obj) {
    console.log(k); // 这里的k 是属性名
    console.log(obj[k]); // 这里的 obj[k] 是属性值
}
再对象里面， 这里的k  是 属性名

遍历 JSON格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。

1. JSON 数据的书写格式是：名称/值对。
2. 里面的属性和值都要用 双引号 括起来

 var json = {
     "id": "1",
     "name": "andy",
      "age": "18",
      "tel": "110120"
 }
 for (var k in json) {
    console.log(k); // 这里的k 是属性名
    console.log(obj[k]); // 这里的 obj[k] 是属性值
}

栈 和 堆

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
堆栈空间分配区别：

　　1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；

　　2、堆（操作系统）： 存储复杂类型(对象)，一般由程序员分配释放， 若程序员不释放，由垃圾回收机制回收。

简单类型又叫做   基本数据类型  或者  值类型，
复杂类型又叫做   引用类型
值类型：简单数据类型/基本数据类型，在存储时，变量中存储的是值本身，因此叫做值类型。
引用类型：复杂数据类型，在存储是，变量中存储的仅仅是地址（引用），因此叫做引用数据类型。

值类型变量 的 数据 直接存放在变量（栈空间）中
var  n1 = 10; 
var n2 = 20;
n1 = n2; 
此时   n1  结果为  20     n2  的值 还是  20  


引用类型
引用类型（复杂数据类型）：通过 new 关键字创建的对象（系统对象、自定义对象）

内置对象

Math对象

Math.PI // 圆周率
Math.floor()/ // 向下取整
Math.ceil() // 向上取整
Math.round() // 四舍五入版 就近取整 注意 -3.5 结果是 -3
Math.abs() // 绝对值
Math.max()/Math.min() // 求最大和最小值
Math.sin()/Math.cos() // 正弦/余弦
Math.power()/Math.sqrt() // 求指数次幂/求平方根

Math.random 生成随机数

随机返回一个小数 ， 取值范围 是 范围[0，1) 左闭右开 0 <= x < 1

案例

1
2
3
4
5
6
求10-20（包含10和20）之间的随机整数
function getRandom(min, max) {
   return Math.floor(Math.random() * (max - min + 1) + min);
}
console.log(getRandom(10, 20))
var a = Math.floor(Math.random() * 11) + 10;

随机生成颜色RGB

1
2
3
4
5
6
7
8
9
10
11
function getRandom(min, max) {
    return Math.floor(Math.random() * (max - min + 1) + min);
}

function getRGB(min, max) {
    var c1 = getRandom(min, max);
    var c2 = getRandom(min, max);
    var c3 = getRandom(min, max);
    return 'rgb(' + c1 + ', ' + c2 + ', ' + c3 + ')';
}
console.log(getRGB(0, 255));

Date对象

/ 获取当前时间，UTC世界时间，距1970年1月1日（世界标准时间）起的毫秒数
var now = new Date(); ()里可以写2018-5-30 17:30 日期数 可以写毫秒数
console.log(now.valueOf()); // 获取距1970年1月1日（世界标准时间）起的毫秒数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Date构造函数的参数
1. 毫秒数 1498099000356		new Date(1498099000356)
2. 日期格式字符串  '2015-5-1'	 new Date('2015-5-1')  或者  new Date('2015/5/1') 
3. 年、月、日……				  new Date(2015, 4, 1)   // 月份从0开始

我们想要 2018-8-8  8:8:8    格式怎么办？ 
toString()		// 转换成字符串
valueOf()		// 获取毫秒值
// 下面格式化日期的方法，在不同浏览器可能表现不一致，一般不用
toDateString()
toTimeString()
toLocaleDateString()
toLocaleTimeString()

getFullYear()		获取当年		dObj.getFullYear()

getMonth()		获取当月（0-11）		dObj.getMonth()

getDate()		获取当天日期		dObj.getDate()

getDay()		获取当天的天（星期几）		dObj.getDay()

getHours()		获取当前小时		dObj.getHours()

getMinutes()		获取当前分钟		dObj.getMinutes()

getSeconds()		获取当前秒钟		dObj.getSeconds()


如何学习一个方法？

Mozilla 开发者网络（MDN）提供有关开放网络技术（Open Web）的信息，包括 HTML、CSS 和万维网及 HTML5 应用的 API。

  • MDN
  • 通过查询MDN学习Math对象的random()方法的使用
  1. 方法的功能
  2. 参数的意义和类型
  3. 返回值意义和类型
  4. demo进行测试

对象的静态成员和实例成员

1
2
3
4
5
6
7
8
实例成员：需要通过 new 出对象实例，然后通过 对象实例.成员 来调用
var dObj = new Date();
var hStr = dObj.getHours(); // 此处通过 对象实例.成员方法() 调用

静态成员：直接通过 对象.成员 来调用
// 比如 Math 这个我们不需要 new 来使用  就是一个对象
var strPi = Math.PI; // 此处通过 对象.成员方法() 调用
var numRandom = Math.random(); // 获取 0-1 之间的 随机小数

格式换日期案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
写一个函数，格式化日期对象，返回yyyy-MM-dd HH:mm:ss的形式

function formatDate(d) {
            //如果date不是日期对象，返回
            if (!date instanceof Date) {
                return;
            }
            var year = d.getFullYear(),
                month = d.getMonth() + 1,
                date = d.getDate(),
                hour = d.getHours(),
                minute = d.getMinutes(),
                second = d.getSeconds();
            month = month < 10 ? '0' + month : month;
            date = date < 10 ? '0' + date : date;
            hour = hour < 10 ? '0' + hour : hour;
            minute = minute < 10 ? '0' + minute : minute;
            second = second < 10 ? '0' + second : second;
            return year + '-' + month + '-' + date + ' ' + hour + ':' + minute + ':' + second;
        }
        console.log(formatDate(new Date()));


计算时间差，返回相差的天/时/分/秒
function getInterval(start, end) {
  var day, hour, minute, second, interval;
  interval = end - start;
  interval /= 1000;
  day = Math.round(interval / 60 /60 / 24);
  hour = Math.round(interval / 60 /60 % 24);
  minute = Math.round(interval / 60 % 60);
  second = Math.round(interval % 60);
  return {
    day: day,
    hour: hour,
    minute: minute,
    second: second
  }
}



做一个倒计时效果
计算公式：
 d = parseInt(总秒数/ 60/60 /24); // 计算天数
 h = parseInt(总秒数/ 60/60 %24) // 计算小时
 m = parseInt(总秒数 /60 %60 ); // 计算分数
 s = parseInt(总秒数%60);  // 计算当前秒数 
function getCountTime(endTime) {
    var d, h, m, s;
    //1. 用用户输入的时间 减去 开始的时间就是 倒计时 
    //2. 但是要注意，我们得到是 毫秒数  然后 把这个毫秒数转换为 相应的 天数 时分秒 就好了
    var countTime = parseInt((new Date(endTime) - new Date()) / 1000);
    // console.log(countTime);
    // 3. 把得到的毫秒数 转换 当前的天数 时分秒
    console.log(countTime);

    d = parseInt(countTime / 60 / 60 / 24); // 计算天数

    h = parseInt(countTime / 60 / 60 % 24); // 计算小时

    m = parseInt(countTime / 60 % 60); // 计算分数

    s = parseInt(countTime % 60); // 计算当前秒数 
    return '还剩下' + d + '天' + h + '时' + m + '分' + s + '秒 ';
}
console.log(getCountTime('2018-5-30 17:30'));




var hours = Math.floor(times%86400/3600);
var minutes = Math.floor(times%86400%3600/60);
var seconds = Math.floor(times%60);

- 百以内取十位 Math.floor(num/10)
		- 百以内取个位 num%10

Array对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
sort  如果调用该方法时没有使用参数，按照字符编码的顺序进行排序。 

    // 1 栈操作(先进后出)
    push()
    pop() 		//取出数组中的最后一项，修改length属性
    // 2 队列操作(先进先出)
    push()
    shift()		//取出数组中的第一个元素，修改length属性
    unshift() 	//在数组最前面插入项，返回数组的长度
    // 3 排序方法
    reverse()	//翻转数组
    sort(); 	//即使是数组sort也是根据字符，从小到大排序
    // 带参数的sort是如何实现的？
    // 4 操作方法
    concat()  	//把参数拼接到当前数组
    slice() 	//从当前数组中截取一个新的数组，不影响原来的数组，参数start从0开始,end从1开始
    splice()	//删除或替换当前数组的某些项目，参数start, deleteCount, options(要替换的项目)
    // 5 位置方法
    indexOf()、lastIndexOf()   //如果没找到返回-1
    // 6 迭代方法 不会修改原数组(可选)
    every()、filter()、forEach()、map()、some()
    // 7 方法将数组的所有元素连接到一个字符串中。
    join()

- 
 


// 1. 使用构造函数创建数组对象
  // 创建了一个空数组
  var arr = new Array();
  // 创建了一个数组，里面存放了3个字符串
  var arr = new Array('zs', 'ls', 'ww');
  // 创建了一个数组，里面存放了4个数字
  var arr = new Array(1, 2, 3, 4);


  // 2. 使用字面量创建数组对象
  var arr = [1, 2, 3];

  // 获取数组中元素的个数
  console.log(arr.length);

- 检测一个对象是否是数组
  - instanceof
  - Array.isArray()     HTML5中提供的方法，有兼容性问题
  函数的参数，如果要求是一个数组的话，可以用这种方式来进行判断
- toString()/valueOf()
  - toString()	 把数组转换成字符串，逗号分隔每一项
  - valueOf()         返回数组对象本身
- 数组常用方法
  演示：push()、shift()、unshift()、reverse()、sort()、splice()、indexOf()

javascript
#javascript
javascripts知识点梳理4
http://www.dwyblog.cn/2019/03/26/javascripts知识点梳理4/
作者
幸福来敲门
发布于
2019年3月26日
许可协议