关于javascript:javascript作用域6

6次阅读

共计 13913 个字符，预计需要花费 35 分钟才能阅读完成。

何谓作用域呢，简略而言，就是标识符在某个范畴起成果与作用，目标是为了进步程序的可靠性，缩小命名抵触

全局作用域
部分作用域

标识符处于整个 <script> 元素或内部独自一个 js 文件的范畴内，便叫做全局作用域

如下：变量 num 处于全局作用域内

  <script>
        var num = 10;
        console.log(num) // 标识符 num 的作用域便属于全局作用域
    </script>

标识符处于函数外部的范畴，便叫做部分作用域

<script>
    function fn() {
        var num = 20;
        console.log(num) //20
    }
    fn() // 调用函数
</script>

依据作用域的不同，变量也分为全局变量和局部变量

全局作用域

在全局作用域下申明的变量属于全局变量

<script>
    var num = 10;
    console.log(num) //10
    function fn() {console.log(num) //10 
    }
    fn()
</script>

在函数外部未应用 var 申明的变量也属于全局变量

<script>
    function fn() {num = 2; // 此时 num 属于全局变量}
    fn()
    console.log(num) // 2
</script>

在函数的外部申明的变量属于局部变量

<script>
    function fn() {var num = 20;}
    console.log(num) // 此时会报错  num 属于局部变量
</script>

函数的形参也能够看做局部变量

<script>
    function fn(num) {console.log(num)// num = 2
    }
    fn(2)
    console.log(num) //  会报错 num 属于局部变量  只能在外部调用
</script>

全局变量在全局的任何地位都能被调用到，只有当浏览器敞开时才会被销毁，因而比拟占内存
局部变量在函数执行完结后便会被销毁，因而比拟节俭内存资源。

ES6 之后引入了块级作用域何谓块级作用域呢 {}就是一个简略的块级作用域

<script>
    if(5>3) {var num  = 20;}
    console.log(num) //20
</script>

外部函数拜访内部函数变量的机制，采纳链式的形式一级一级向上获取获取数据，称为作用域链（就近准则）

<script>
    var num = 20;
    function fn() {
        var num =25;
        function fn2()  {console.log(num) //25 就近准则
        }
        fn2()}
    fn()
</script>

    <script>
    function f1() {
        var num = 123;
        function f2() {console.log(num)
        }
    f2() //123}

    var num = 456;
    f1()
</script>

<script>
    var a = 1;
    function fn1() {
        var a = 2;
        var b = '22';
        fn2() 
        function  fn2(){
            var a = 3;
            fn3();
            function fn3() {
                var a = 4;
                console.log(a); //a = 4
                console.log(b); //b = '22'
            }
        }
    }
    fn1()
</script>

js 引擎执行 js 代码分为两步：预解析代码执行

预解析：js 引擎会把 js 外面的所有应用 var 申明的变量和 function 申明的函数晋升到以后作用域的最顶部
代码执行：依照代码执行的程序从上往下执行

预解析分为变量预解析及函数预解析

变量预解析会把变量申明晋升到以后作用域的最后面，不晋升赋值操作
函数预解析会把函数申明晋升到以后作用域的最后面，不调用函数

<script>
    console.log(num); //undefined
    var num = 10;
/* 上述代码的步骤相当于
* var num;

* console.log(num);
* num = 10;
*/

</script>

函数预解析的第一种状况

<script>
    fn() //hello

    function fn() {console.log('hello')
    }

    /* 上述代码相当于
    *    function fn() {*     console.log('hello')
       }
      fn()
    */
</script>

函数预解析的第二种状况

<script>
    fn()
    var fn = function() {console.log('222')
    }

    /* 上述代码相当于
    var  fn;
    fn(); // 会报错
    fn = function() {cosnle.log('222')
    }
    */
</script>

<script>
    var num = 10;
    fun();
    function fun() {console.log(num); //undefined
        var num = 20;

    }
    


    /* 下面的代码相当于以下步骤
    var num;
      function fun() {
          var num;
         console.log(num);
         num = 20;

    }
    num = 10;
    fun()

    */


</script>

<script>
    var num = 10;
    function fn() {console.log(num); //undefined
        var num = 20;
        console.log(num) //20
    }

    fn();

    /* 上述代码相当于以下操作
    var num ;
    function fn() {
        var num;
        console.log(num);
        num = 20;
        console.log(num);

    }
    num = 10;
    fn()
 */
     
</script>

<script>

    var a = 18;
    f1();
    function f1() {
        var b = 9;
        console.log(a); //underfined
        console.log(b); // 9
        var a  ='123'

    }

    /* 上述代码相当于以下操作
     var a;
       function f1() {
        var b;
        var a;
        b = 9;
        
        console.log(a);
        console.log(b);
         a  ='123'

    }
    a = 18;
    f1();
    */

</script>

<script>
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；a =  9；b =9；c = 9;
    console.log(a); //9
    console.log(b); //9 
    console.log(c) //9 
}
f1();
console.log(c); //9 
console.log(b); // 9
console.log(a); // 报错

*/



</script>

对象是一组无序的相干属性与办法的汇合，所有的事物都能够是对象，例如数值字符串数组函数等等

对象是由属性与办法的汇合

属性：事物的特色，在对象中用属性示意(罕用名词)
办法：事物的行为，在对象中用行为示意（罕用动词）

保留一个值时，能够用到变量，保留多个值时，能够用到数组示意。对象能够示意事物的具体信息，让构造更清晰。

利用字面量创建对象
利用 new Object 创建对象
利用构造函数创建对象

<script>

    // 应用对象
    var object = {
        name:'尧子陌',
        age :24,
        sex:"男",
        height:'173cm',
        sayHi:function() {console.log('爱学习 爱劳动 爱国家')
        }
        
    }
    // 调用对象的属性
    console.log(object.name);
    console.log(object['name'])
    // 调用对象的办法
    object.sayHi()

</script>

注意事项

对象之间采纳键对值的模式两头用英文状态下的冒号相隔开
多组属性之间用英文状态下的逗号相隔开
调用对象的办法切记不要遗记小括号

调用对象的属性

对象. 属性
对象[‘ 属性 ’]

调用对象的办法

对象. 办法()

变量是独自申明赋值独自存在
属性是对象外面的变量不须要申明用来形容事物的特色
函数是独自存在通过函数名（）来进行调用
办法是对象外面的函数，通过对象. 办法（）来进行调用。用来形容事物的行为与性能

注意事项

应用 new Object 创建对象并采纳等号赋值的形式，增加对象的办法和属性。
多组属性之间采纳分号相隔开；
调用对象的办法和属性和字面量创建对象统一

<script>
  var object = new Object();
  object.name = '尧子陌';
  object.sex= '男';
  object.height = '175cm';
  object.kill = function() {console.log('爱生存')
  }
  console.log(object)
   console.log(object.name);
   object.kill()
</script>

构造函数是一种非凡的函数，次要用来初始化对象，即为对象成员变量赋初始值，它与 new 一起应用，把对象中公共的属性与办法抽取进去，封装到函数外面。

注意事项

构造函数名的首字母要大写
构造函数不须要 return 便能够返回后果
构造函数必须跟 new 关键字一起应用
属性与办法后面必须要应用 this


 <script>
    function Star(name,sex,age,behavior) {
        this.name = name;
        this.sex = sex;
        this.age = age ;
        this.behavior = function(){console.log('会说 会唱')
        }
    }

    var  people1 = new Star('尧子陌','男',"24");
    console.log(people1)
    people1.behavior()
</script>

应用构造函数创立 猪八戒 后羿两个对象

<script>
    function Hero(name,sex,age) {
        this.name =name;
        this.sex = sex;
        this.age = age;
        this.skill = function(name) {console.log(name)
        }

    }
    var people1 = new Hero('猪八戒',"男",'1200');
    people1.skill("毫发无损");
    console.log(people1)
    
    var people2 = new Hero('后羿',"男",'1200');
    people1.skill("只识弯弓射大雕");
    console.log(people2)


</script>

构造函数抽取对象的公共属性与办法，泛指某一大类
应用 new 关键字创立的对象的过程被称为对象实例化

new 在执行过程

1. 在内存中创立一个空对象

2.this 指向这个新的对象

3. 执行构造函数外面的代码给这个新对象增加属性与办法

4. 返回这个新对象（构造函数不须要 return）

for(变量 in 对象) { }

变量用 key 示意但还是简写 k

<script>
   var obj = {
       name:'尧子陌',
       sex:"男",
       age:"18",
       skill:function() {return "天生帅气 人见人爱"}
   }
   for(var k in obj) {console.log(k) // 打印对象的属性
       console.log(obj[k]) // 打印对象的属性值
   }


</script>

对象能够让构造更加清晰
对象是简单类型 object
实质：对象就是一组无序的相干属性与办法的汇合
构造函数是泛指一大类
对象是指具体的一个的事物
应用 for in 能够遍历对象

javascript 中对象分为 3 种：自定义对象  内置对象  浏览器对象

后面两种对象是 js 根底，属于 ECMAscript; 浏览器对象属于咱们 js 独有的

内置对象属于 js 语言自带的一些对象，这些对象供开发者应用。进步开发效率。js 内置的对象：Math  Data   Array  string 等等

MDN:developer.mozilla.org/zh-CN/

查看该办法的性能
查看外面参数的类型与意
查看返回值的意义和类型
通过 demo 进行测试

Math 是 js 中的内置对象，它领有数学常数属性和数学函数办法，它并不是一个函数对象。Math.max: 返回多个数值中的最大值     Math.min: 返回多个数值中的最小值

<script>
    console.log(Math.PI) // 打印圆周率
   console.log(Math.max(5,20,60,100))  // 获取最大值
   console.log(Math.min(5,20,60,100))  // 获取最小值
</script>,

<script>
  var myMath = {
      PI:3.141592653589793,
      Max:function() {var max = arguments[0];
          for(var i = 0;i<arguments.length;i++) {if(max<arguments[i]) {max = arguments[i]
              }
          }
          return max;
      },
      Min:function() {var min = arguments[0];
          for(var i = 0;i<arguments.length;i++) {if(min > arguments[i]) {min = arguments[i]
              }
          }
          return min;
      }
      
  }

//   调用对象
console.log(myMath.PI) // 获取圆周率
console.log(myMath.Max(5,20,450,650)); // 获取最大值
console.log(myMath.Min(20,1,6,90,50)); // 获取最小值

</script>

<script>
    console.log(Math.abs(1)) //1 
    console.log(Math.abs(-1)) //1 
    console.log(Math.abs('-2')) //2 会将字符串的 2 转换成数值 2
    console.log(Math.abs('尧子陌')) // 遇到非数字 间接显示 NaN

</script>

Math.floor() 向下取整
Math.ceil() 向上取整
Math.round() 四舍五入取整

<script>
// Math.floor() 向下取整
console.log(Math.floor(-2.5)) // -3 
console.log(Math.floor(1.8))  // 1
console.log(Math.floor(2.5))  // 2
console.log(Math.floor(0.5))  // 0


//Math.ceil() 向上取整
console.log(Math.ceil(2.6)) //3
console.log(Math.ceil(5.8)) // 6 
console.log(Math.ceil(-1.5))// -1 
console.log(Math.ceil(0.6)) //1


//Math.round() 四舍五入取整
console.log(Math.round(2.6)) //3
console.log(Math.round(5.8)) // 6 
console.log(Math.round(-1.5))// -1 
console.log(Math.round(0.6)) //1
</script>

留神:Math.round(-1.5)及 Math.ceil(-1.5)会往大的取值

<script>
  console.log(Math.random()) // 生成 0~1 之间的随机数
</script>

  Math.floor(Math.random() * (max - min + 1)) + min;

<script>
    function getRandom(min,max) {return  Math.floor(Math.random()*(max-min+1))+min
    }

    console.log(getRandom(1,10))  // 生成 1~10 之间任意的整数
</script>

<script>
    // 封装一个获取随机数的函数
       function getRandom(min,max) {return  Math.floor(Math.random()*(max-min+1))+min
    } 

    var random = getRandom(1,10);

   

    while(true) {var userName  = prompt("请输出数字"); // 必须写在 while 语句外面 输出谬误，则会始终会弹出输入框的后果
        
        if(userName>random) {alert("对不起 你猜大了")
        }else if(userName<random) {alert("对不起 你猜小了")
        }else  {alert("祝贺你 你猜对了");
            break;
        }
    }
</script>

注意事项

Date 对象和 Math 对象不一样，它属于构造函数
Date 对象用来解决日期和工夫

<script>
    var time = new Date();
    console.log(time) // 获取以后工夫
</script>

Date()外面的参数代表工夫个别用字符串的模式写入参数

<script>
    var time = new Date('2020-7-17  15:49');
    console.log(time) 
</script>

<script>
  var date = new Date(); // 实例化对象

  var year = date.getFullYear() // 返回以后的年份
  var month = date.getMonth()+1  // 获取以后的月份，因为返回的月份比理论月份小一 所以加 1 
  var dates= date.getDate();// 获取以后日期
  var arr = ['星期日','星期一','星期二','星期三','星期四','星期五','星期六']
  var days = date.getDay() // 获取以后星期几

  console.log('往年是:'+year+"年" +month+"月"+dates+"日"+arr[days])
</script>

<script>
    function getTimer() {var date = new Date();
        var h  = date.getHours() // 获取以后的工夫
         h= h<10?"0"+h:h
        var m = date.getMinutes()// 获取以后的分钟
          m= m<10?'0'+m:m
        var s = date.getSeconds() // 获取以后的秒
          s= s<10?"0"+s:s;
        return h+":"+m+":"+s
    }
   console.log(getTimer())
</script>

共有四种办法

<script>

    var date = new Date();
    console.log(date.valueOf()) 
    console.log(date.getTime())
    console.log(+new Date()) 
    console.log(Date.now()) //h5 新增办法
</script>

外围算法

用户输出的工夫减去以后的工夫即为倒计时
用工夫戳来做，用户输出的工夫总毫秒数减去以后工夫总毫秒数，失去的就是残余的工夫的毫秒数。
把剩余时间的总毫秒数转换为天时分秒

<script>
    function  countTime(time) {var nowTime = +new Date() // 获取以后工夫的总毫秒数
        var inputTime = +new Date(time) // 获取用户输出的总毫秒数
        var times = (inputTime-nowTime) /1000  // 失去总秒数
        var d = parseInt(times/60/60/24); 
        d = d<10?'0'+d :d
        var h = parseInt(times/60/60%24);
        h = h<10?'0'+h :h
        var m =parseInt(times/60%60);
        m = m<10?'0'+m :m
        var s = parseInt(times%60)// 取整
        s = s<10?'0'+s :s

        return d +"天"+ h +"时"+m +"分"+s +"秒"


    }
    

    console.log(countTime("2020-10-17 18:00:00"))
</script>

new Array() 若没有参数则默认为空数组
new Array(5) 参数若有一个数字则代表以后数组的长度
new Array(5,5,6) 参数若有 2 个及 2 个以上外面则是数组元素

 <script>
    var arr1 = new Array() // 申明一个空数组
    var arr2 = new Array(5) // 一个参数则代表数组的长度
    var arr3 = new Array(5,6,9,89) // 两个以上的参数则代表数组元素

    console.log(arr1)
    console.log(arr2)
    console.log(arr3)
</script>

通过 instanceof 用来检测类型是否为数组
通过 Array.isArray(参数)来检测是否为数组

上述办法若参数为数组则显示 true 若参数不是数组则返回 false

<script>
    var arr = [];
    var obj = {}
    console.log(obj instanceof Array)//instanceof 用来检测类型是否为数组
    console.log(arr instanceof Array);//instanceof 用来检测类型是否为数组
</script>

<script>
    var arr  = [];
    var obj = {};
    console.log(Array.isArray(arr)) //isArray()用来检测是否为数组 
    console.log(Array.isArray(obj)) //isArray()用来检测是否为数组

</script>



<script>
    /* 反转数组 */
    function reverse(arr) {if(Array.isArray(arr)) {var newArr = [];
            for(var i = arr.length-1;i>=0;i--)  {newArr[newArr.length] = arr[i]
            }
            return newArr
        }else {return '不属于数组类型 请从新输出数组'}
        

    }
   
    console.log(reverse([5,50,60,96,50]))  
    console.log(reverse(5,50,60,96,50))    
</script>

<script>
    var arr  = [1,2,3];
    console.log(arr.push(4,5,6))  // 显示的是数组的个数
    console.log(arr) // 原数组也会扭转
</script>

注意事项

push 是能够给数组的开端增加一个或者多个数组元素
push（）前面的参数间接写数组元素即可
push 结束之后显示的是新数组长度
原数组的也会发生变化

<script>
     var arr = [20,50,60,90,90];
     console.log(arr.unshift("尧子陌","hello")); // 返回的是新数组的长度
     console.log(arr) 
</script>

注意事项

unshift 是能够给数组的结尾增加一个或者多个数组元素
unshift()前面的参数间接写数组元素即可
unshift 结束之后显示的是新数组的长度
原数组的也会发生变化

<script>
    var arr = [5,20,60,90,45,50];
    console.log(arr.pop()); //50
    console.log(arr) 
</script>

注事事项

pop()是删除数组的最初一项元素返回值是数组的最初一个元素
pop()外面没有参数
原数组也会产生扭转

<script>
    var arr = [5, 20, 60, 82, 80, 85];
    console.log(arr.shift()) //5
</script>

注意事项

unshift 是删除数组的第一个元素
返回值是数组的第一个元素
unshift（）外面没有参数
原数组会发生变化

把一个蕴含工资的数组[1500,1200,2000,2100,1800], 要求把数组中的工资超过 2000 的删除，残余的放到新数组外面

<script>
    var arr = [1500, 1200, 2000, 2100, 1800, 2300, 2500, 6500];
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {if (arr[i] > 2000) {newArr.push(arr[i]) // 采纳 push 的办法 把大于 2000 的数组元素存储到新数组
        }
    }
    console.log(newArr);
</script>

目标：实现数组反转

<script>
    var arr = ['pink', 'balck', 'yellow', 'red'];
    arr.reverse() // 实现数组反转成果
    console.log(arr)
</script>

目标: 数组排序

a -b：实现升序
b -a : 实现降序

<script>
    var arr = [50, 60, 30, 60, 8, 20];
    arr.sort(function(a, b) {return a - b //a - b 是升序   b- a 是降序})
    console.log(arr)
</script>

参数为数组元素，返回的后果是该数组元素的索引号，从后面开始查找。
如果数组中没有该数组元素，且返回的索引号为 -1

<script>
    var arr = ["尧子陌", "临风笑却世间", '22', '33', '55'];
    console.log(arr.indexOf('临风笑却世间')) //1
    console.log(arr.indexOf('惊鸿')) // -1
</script>

参数为数组元素返回的后果为该数组元素的索引号，从前面开始查找
如果数组中没有该数组元素，则返回的索引号为 -1

<script>
    var arr = ['尧子陌', '惊鸿', '220', '550', '665', '尧子陌', '惊鸿', '220', '550', '665'];
    console.log(arr.lastIndexOf('惊鸿')) // 6
    console.log(arr.lastIndexOf('520')) // -1
</script>

思路如下

遍历旧数组
拿旧数组的数组元素去查问新数组，如果该数组元素在新数组没有呈现过，则增加，反之则不增加

<script>
    function unique(arr) {var newArr = []; // 申明一个新数组
        for (var i = 0; i < arr.length; i++) {if (newArr.indexOf(arr[i]) === -1) {newArr.push(arr[i])
            }
        }
        return newArr // 返回新数组

    }
    console.log(unique(['c', 'a', 'c', 'b', 'd', 's', 'c', 'aa', 'b', 'a', 'a']))
</script>

利用 toString()将数组转换成字符串

<script>
    var arr = [20, 50, 60, '尧子陌'];
    console.log(arr.toString()) // 控制台打印后果
</script>

利用 join 可将数组转换成字符串，另外还能够跟上分隔符

<script>
    var arr = [20, 50, 60, '尧子陌'];
    console.log(arr.join("&")) // 控制台打印后果
</script>

思考问题:

字符串为根本数据类型，为什么会有办法和属性呢? 很简略，因为有根本包装数据类型

何谓根本包装类型呢，简略而言，就是把根本数据类型转换成简单数据类型

<script>
    var str = 'strong';
    console.log(str.length) //6

/*
1. 利用长期变量把根本数据类型包装成简单数据类型
    var temp = new String('strong');
2. 把长期变量赋值给 str
    str = temp;
3. 销毁长期变量 temp
    temp = null
*/
</script>

Js 中有三种非凡援用类型：Number String Boolean

利用变量名可将字符串从新赋值，但相当于在内存中从新开拓一块空间，因而不要拼接字符串，会造成电脑卡顿

indexOf(“ 查找的字符元素 ”,[起始的地位])
lastIndexOf(“ 查找的字符元素 ”，[起始地位])

注意事项

应用 lastIndexOf()的时候，第二个参数为从哪个索引号开始查找，是从右往左查找的

<script>
    var str = 'acdefghibcdezafghdefghaijklbmnb';
    console.log(str.indexOf('a', 3)); // 查找 a 从索引 3 开始查找
    console.log(str.indexOf('b', 3)) // 查找 b 从索引 3 开始查找
    console.log(str.lastIndexOf('b', 26)) // 查找 b 从索引 26 开始查找  -1
</script>

<script>
    var str = 'abcofoxyozzopp';
    var num = 0; // 统计 o 呈现的次数
    var index = str.indexOf('o') // 查找 o 第一次呈现的地位
    while (index !== -1) {console.log(index);
        num++
        index = str.indexOf('o', index + 1)

    }
    console.log('o 呈现的次数：' + num)
</script>

思路如下

先查找第一个 o 呈现的地位
indexOf()的索引只有不是 -1，便持续向下查找
indexOf()只能查找第一个 o, 所以前面的查找，肯定是以后索引加 1，从而持续查找

<script>
    var str = 'andy'
    console.log(str.charAt(2)) //d  依据索引地位返回字符
</script>

<script>
    var str = 'YaoZiMo';
    for (var i = 0; i < str.length; i++) {console.log(str.charAt(i)) // 打印字符串的每一项元素

    }
</script>

<script>
    var str = 'andy'
    console.log(str.charCodeAt(2)) //100  依据索引地位返回绝对应的字符 ASCII 码
</script>

<script>
    var str= 'andy';
    console.log(str[2]) //d
</script>

判断一个字符串 ’abcoefoxyozzopp’ 中呈现次数最多的字符并统计次数

外围算法：利用 charAt()遍历这个字符串
把每个字符都存储给对象，如果对象没有该属性，就为 1，如果存在就 +1
利用遍历得出最大值和字符

<script>
    var str = 'abcoefoxyozzopp';
    var obj = {};
    for (var i = 0; i < str.length; i++) {var charts = str.charAt(i)
        if (obj[charts]) {// obj[charts]失去是属性值
            obj[charts]++
        } else {obj[charts] = 1;
        }
    }
    console.log(obj)

    // 开始遍历对象
    var max = 0;
    var ch = ""
    for (var k in obj) {if (obj[k] > max) {max = obj[k];
            ch = k;
        }
    }

    console.log("次数最多的字符:", ch)
    console.log("次数为:" + max)
</script>

<script>
    var str = 'hello';
    console.log(str.concat('word')) //helloword
</script>

<script>
    var str = 'hello my name is china';
    console.log(str.substr(2, 3)) //llo
</script>

<script>
    var str = 'hello hello'
    console.log(str.replace('o', 'y'))
</script>

将下列字符串中的‘a’替换为‘b’

<script>
    var str = 'aaccvricunrbeuaaaaaadeufban';
    while (str.indexOf('a') !== -1) {str = str.replace('a', 'b')
    }
    console.log(str)
</script>

split(‘ 分隔符 ’)

目标：将字符串转换成数组

<script>

    var str = 'pink,blue,yellow';
    console.log(str.split(','))

    var str = 'hello&dark&yellow';
    console.log(str.split('&'))
</script>

正文完

javascript

发表至： javascript

2020-08-14

0

关于javascript:可视化搭建-场景实战

CTF编码全家桶小程序

深入解析V8中sort的工作原理

每周知识汇总20198262019830

关于redis:聊聊RespServer

关于javascript:javascript作用域6

javascript 作用域

JS 的作用域

全局作用域

部分作用域

变量的作用域

全局变量

局部变量

全局变量和局部变量的区别

块级作用域

作用域链

作用域链习题

习题一

习题二

JavaScript 预解析

变量预解析

函数预解析

预解析案例

案例一

案例二

案例三

案例四

javascript 对象

什么是对象？

为什么须要对象？

如何创建对象

采纳字面量的形式创建对象

如何调用对象的属性与办法呢

变量与属性 函数与办法的区别

利用 new Object 创建对象

构造函数

构造函数的案例

构造函数与对象

new 关键字

遍历对象

总结

js 内置对象

如何查文档呢

如何学习对象中的办法？

Math 对象

案例：封装一个属于本人的数学对象，外面有 PI 最大值和最小值。

Math 对象中罕用的办法

取绝对值办法:Math.abs()

三个取整办法

获取随机数

Math.random()：生成随机数（0~1)

生成 [min,max] 之间的整数 包含 max min

案例：生成 1~10 之间的任意整数

猜数字游戏

日期对象

获取以后的工夫

Date()外面的参数

日期格式化

案例：拼出以后的日期

封装一个日期格式化函数

获取日期的总的毫秒数（工夫戳）

倒计时

数组

如何检测是否为数组

instanceof

Array.isArray()

通过判断数组的形式来反转数组

数组办法

push()

unshift()

pop()

shift()

案例

数组排序

reverse()

sort()

数组索引办法

indexOf()

lastIndexOf()

数组去重(重点)

数组转换成字符串

toString()

join(分隔符)

字符串对象

根本包装类型

变量与属性函数与办法的区别

生成 [min,max] 之间的整数包含 max min