JS视频知识点整理 【day02】

1.类型转换

①转换成字符串的方式

//转换字符串的三种方式
//null和undefined没有tostring()方法
var num=1;
var str1=num.toString();
var str2=String(num);   //字符串类型的'1'
var s=1+'';
console.log(str1,str2,s);

②其他类型转化成字符串

var na=NaN;
var u=undefined;
var n=null;
var bool=true;
var arr=[1,2,3];
var obj={};
var str1=toString(na);        //'[object Undefined]'
//var str2=u.toString();      //报错
//var str3=n.toString();      //报错
var str2=String(u);           //'undefined'
var str3=String(n);           //'null'
var str4=bool.toString();     //'true'
var str5=arr.toString();      //'1,2,3'
var str6=obj.toString();      //'[object Object]'
console.log(str1,str2,str3,str4,str5,str6);

③其他类型转换成boolean

var res='1';
var r=Boolean(res);
console.log(r);  //true

④ 其他类型转换成数值类型

//数值转换数值
var str='1.0';
var n1=Number(str);      //1
var n2=parseInt(str);    //1
var n3=parseFloat(str);  //1
console.log(n1,n2,n3);
var str='1.01';
var n1=Number(str);      //1.01
var n2=parseInt(str);    //1
var n3=parseFloat(str);  //1.01
console.log(n1,n2,n3);
//空字符串转换数值
var str='';
var n1=Number(str);      //0
var n2=parseInt(str);    //NaN
var n3=parseFloat(str);  //NaN
console.log(n1,n2,n3);
//null转换数值
var str=null;
var n1=Number(str);      //0
var n2=parseInt(str);    //NaN
var n3=parseFloat(str);  //NaN
console.log(n1,n2,n3);
//带数值的字符串转换数值
var str='111hello';
var n1=Number(str);      //NaN
var n2=parseInt(str);    //111
var n3=parseFloat(str);  //111
console.log(n1,n2,n3);
//布尔类型转换数值
var str=true;
var n1=Number(str);      //1
var n2=parseInt(str);    //NaN
var n3=parseFloat(str);  //NaN
console.log(n1,n2,n3);
//undefined转换数值
var str=undefined;
var n1=Number(str);      //NaN
var n2=parseInt(str);    //NaN
var n3=parseFloat(str);  //NaN
console.log(n1,n2,n3);
//对象转换为数值
var str={};
var n1=Number(str);      //NaN
var n2=parseInt(str);    //NaN
var n3=parseFloat(str);  //NaN
console.log(n1,n2,n3);

2.流程控制语句

If-else

//三个数值,从大到小排序
var a=2, b=1,c=3;
var n1;
if(a<b){
    n1=a;
    a=b;
    b=n1;
}
if(a<c){
    n1=a;
    a=c;
    c=n1;
}
if(b<c){
    n1=b;
    b=c;
    c=n1;
}
console.log(a,b,c);   //3 2 1

switch

//判断某一天为工作日还是休息日
var day=1;//工作日
switch(day){
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        console.log('工作日');
        break;
    case 6:   //default:
    case 7:
        console.log('休息日');
        break;
}

for

//从1加到100
var sum=0;
for(var i=1;i<=100;i++){
    sum +=i;
}
console.log(sum);  //5050

while

//从1加到100
var i=1;
var sum=0;
while(i<=100){
    sum+=i
    i++;
}
console.log(sum);

do-while

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

break 和continue

在嵌套循环中,只对当前层有作用

标记

//希望b=5时结束全部循环,使用标记
a1:for(var a=1;a<=10;a++){
    for(var b=1;b<=10;b++){
        if(b==5)
            break a1;
        console.log(a,b);
    }
}

3.流程语句例子

//在当入职时,工资为10k,每年增幅5%,20年后工资为多少?
var n=10000;
for(var i=1;i<=20;i++){
    n+=n*0.05;
}
console.log(n);
//五角,1元,5元的纸币搓成20元,有多少种情况?
var n=0;
for(var i=0;i<=40;i++){
    for(var j=0;j<=20;j++){
        for(var k=0;k<=4;k++){
            if(i*0.5+j*1+5*k==20){
                n++;
            }
        }
    }
}
console.log(n);  //55

4.对象

①Js工作原理

        初期,设计初衷运行在浏览器端的脚本语言(dom)

        单线程的嵌入式脚本语言,执行代码线程只有一个(因为如果为多线程,会出现多个线程同时操作同一个dom的问题)也会出现问题:任务需要排队,如果某一个任务执行时间很长,会造成阻塞

          解决方式:采用异步方式

                  第一种:setTimeOut()  某一些功能需要等待一些时间才执行

                  第二种: Ajax  这个数据回来时间不确定

②Js垃圾回收机制

             主要解决:内存中出现一些不再需要的变量-----内存泄漏

             工作方式:会间隔的不定期的寻找不再使用的变量,并释放他们

            方法:标记清除,引用计数

            被视为垃圾的情况:①没有被引用的变量

                                            ②几个对象相互引用成为闭环

            不会被视为垃圾的情况:①全局变量-----时刻待命

                                                  ②有具体的引用关系---闭包(在函数的内部还有函数,内部的函数引用外部函数的变量)

        ③垃圾回收机制示例

 function test(){
    var num=0;
    console.log(++num);
}
//每次在函数的功能体中,每一次执行完毕后,不被引用的变量会被销毁
test();   //1
test();   //1
test();   //1

5.对象的创建

      ①字面量方式

var stu={
    name:'xiaoming',
    height:180,
    weight:60,
    money:'多',
    cook(){
        console.log(this.name+'去做饭')
    },
    housework(){
        console.log('去做家务')
    },
}

   ②构造函数方式

var stu2=new Object();
stu2.name="xiaohong";
stu2.height=160;
stu2.weight=45;
stu2.money='多';
stu2.sayHello=function(){
    console.log('hello');
}

6.访问属性和方法

//访问属性的方式
console.log(stu.name);
console.log(stu['name']);
//方法的调用
stu.cook();

//对象的遍历for...in  能被for..in打印的属性成为可枚举属性(默认情况下,自定义的属性都是可以被枚举的)
for(k in stu){   //k表示属性的键
    //console.log(k);// name height weight money cook housework
    console.log(stu[k]); //xiaoming 180 60 多 [Function: cook] [Function: housework]
}

删除某一个属性 只能删除自定义属性,无法删除继承属性

delete stu.money; 

新增属性  新增时,如果原对象中没有该属性,为新增,如果有,为修改

stu.money='少';

7.valueOf和toString

①这两个方法都为对象的原始方法

②valueOf为对象的原始值,通常不会显示的调用,通常由js自动在后台进行调用

③toString本身的一个作用是做字符串的转换,也会进行自动调用

④如果我们都重写了这两个方法,在进行运算时,优先调用valueOf,在进行显示时,优先调用toString,

⑤如果我们只重写了一个方法,那么无论是运算还是重写,都会调用重写的方法

⑥如果两个都重写,我们会优先调用valueOf

示例如下:

var obj={
    num:1,
    toString:function(){
        return this.num+1;
    },
    valueOf:function(){
        return this.num+2;
    },
}
console.log(obj==2);   //false 这时候调用valueOf

使用valueOf()实现一个累加的实例,每次调用obj时,valueOf()方法都会被调用

var obj={
    num:1,
    toString:function(){
        return this.num+100;
    },
    valueOf:function(){
        return this.num++;
    },
}
//因为num在valueOf中被引用,所以num不会被当作垃圾回收
console.log(obj==1);    //true
console.log(obj==2);   //true
console.log(obj==3)     //true

如果没有重写valueOf,那么转数值类型返回NaN,如果重写,优先调用valueOf

var obj={
    num:1,
    toString:function(){
        return this.num+100;
    },
    valueOf:function(){
        return this.num++;
    },
}
console.log(Number(obj));  //1

8.在对象中的检测属性和方法

//in 检测某个属性是否是某个对象的*属性或继承属性
//hasOwnProperty(propertyName)  检测某个属性是否是某个对象的自有属性
//propertyIsEnumerable 检测某个属性是否是某个对象的自有属性,可枚举的属性
var obj={
    name:'xiaoming',
}
console.log('toString' in obj);  //true
console.log(obj.hasOwnProperty('toString'));  //false
console.log(obj.propertyIsEnumerable('toString')); //false

检测对象是否在同一个原型链中

检测对象是否是某个构造函数的实例

//in 检测某个属性是否是某个对象的*属性或继承属性
//hasOwnProperty(propertyName)  检测某个属性是否是某个对象的自有属性
//propertyIsEnumerable 检测某个属性是否是某个对象的自有属性,可枚举的属性
var obj={
    name:'xiaoming',
}
//isPrototypeOf()检测一个对象是否在另一个对象的原型链上(原型的指向)
//instanceof()检测一个对象是否是某个构造函数的实例 new
var str=new String('zhangsan');
console.log(str instanceof String); //true
console.log(str instanceof Object);  //true
console.log(String.prototype.isPrototypeOf(str));  //true
console.log(Object.prototype.isPrototypeOf(str));  //true
function Animal(){};
var dog=new Animal();
console.log(dog instanceof Animal);  //true
console.log(dog instanceof Object);  //true
console.log(Animal.prototype.isPrototypeOf(dog));  //true
console.log(Object.prototype.isPrototypeOf(dog));  //true
var obj={};
console.log(Object.prototype.isPrototypeOf(obj));  //true
function Dog(){};
var dog2=new Dog();
console.log(Animal.prototype.isPrototypeOf(dog2));  //false

上一篇:Java学习day02


下一篇:Java学习day02-2