JS学习笔记

1.字符串长度

length获取字符串长度

var str="我是程序猿"；
alert(str.length);

2.字符串拼接

数值相加，字符相连

变量不能写在字符串里面，是通过和字符串相连的方式

console.log('沙漠'+'骆驼');

3.数字型转为字符串类型

//变量.toString()
var num=1;
var str=num.toString();
console.log(str);
//String(变量）
console.log(String(num));
//隐式转换，拼接字符串
console.log(num+'');

字符型转化为字符型

//转换为整型
parseInt('78');
//转换为浮点型
parseFloat('78.21');
//强制转换
Number('12');

4.行内式，内嵌式，外部

5.数组

//1.利用new创建数组
var arr=new Array();
//arr为数组名
//2.利用数组字面量创建数组
var arr=[];
var arr1=[1,2,'pink',true];
//数组中可以存放任意类型的数据

将数组转换为字符串

var arr=['red','green','blue'];
var str='';
var sep='*';
for(var i=0;i<arr.length;i++)
{
    str+=arr[i]+sep;//将数组转换为字符串并以*分隔
}
//遍历数组，使用length得到数组长度
console.log(str);

6.函数

function getSum(num1，num2)
{
    console.log(num1+num2);
}
getSum(1,3)；//调用函数

7.arguments的使用

当不确定参数个数时，使用arguments来获取，arguments是当前函数的一个内置对象，arguments对象中存储了传递的所有实参。 arguments为伪数组，具有length属性，按照索引方式进行存储，

function fn()
{
    for(var i=0;i<=arguments.length;i++)
    {
        console.log(arguments[i]);
    }
}//遍历实参

8.全局变量即全局作用域下的变量，如果在函数内部没有声明直接赋值的变量也叫全局变量

9.（1）预解析：js引擎会把js里面的所有var还有function提升到作用域的最前面，即变量预解析和函数预解析。

变量预解析  把所有的变量说明提升到作用域最前面，不提升赋值操作

函数预解析 把所有的函数声明提升到作用域的最前面，不调用函数

10.对象

对象字面量：花括号{}内包含表达这个属性和方法，{}里面采用键值对的形式表示，键相当于属性名，值相当于属性值（任意类型）

调用对象的属性：1)对象名.属性名

                              2)对象名['属性名']

调用对象的方法：对象名.方法名()

//1.利用字面量创建对象
var obj={
    uname:'刘德华',//1.多个属性和方法中间用逗号隔开
    age:18,
    sayHi:function(){  //2.方法冒号后面跟的是一个匿名函数
        console.log('hi');
    }
}
console.log(obj.uname);
console.log(obj['uname']);//调用对象的属性
obj.sayHi();//调用对象的方法


//2.利用new object创建对象
var obj=new Object();
obj.uname='刘德华';
obj.sayHi=function(){
    consolr.log('hi');
}
console.log(obj.uname);
console.log(obj['uname']);
obj.sayHi();


//3.利用构造函数创建对象（对象实例化）
function Star(uname,age,sex)//1.构造函数名首字母要大写
{                           //2.构造函数不需要return就可以返回结果
    this.name=uname;        //4.属性和方法前面必须有this
    this.age=age;
    this.sex=sex;
    this.sing=function(song){
        console.log(song);
    }
}
var ldh=new Star('刘德华'，18，'男');//3.调用构造函数必须使用new
console.log(ldh.name);
console.log(ldh.age);
ldh.sing();
//function 构造函数名()
//{
//    this.属性名=值；
//    this.方法名=function(){}
//}
//new 构造函数名();

new关键字的执行过程

1）new 构造函数可以在内存中创建一个空对象

2）this 指向创建的空对象

3）执行构造函数里面的代码，给这个空对象添加属性和方法

4）返回这个对象

遍历对象

for (var k in obj) {
    console.log(k);//得到属性名
    console.log(obj[k]);//得到属性值
}

    内置对象

1）Math数学对象

 2）日期对象

是一个构造函数必须使用new来调用对象

var date=new Date();//1.使用Date，如果没有参数则返回系统当前时间
console.log(date);
//参数的常用写法 数字型 2019，10，01 或者是 字符串型'2019-10-1 8:9:9'
var date1=new Date(2019，10，01);


//封装一个函数返回当前的时分秒
function getTime(){
    var time=new Date();
    var h=time.getHours();
    h=h <10?'0'+h:h;
    var m=time.getMinutes();
    m=m<10?'0'+m:m;   
    var s=time.get.Seconds();
    s=s<10?'0'+s:s;
    return h+':'+m+':'+s;
}
console.log(getTime());

//获得Date总的毫秒数(时间戳)，是距离1970年1月1号过了多少毫秒数
//1.使用valueOf() getTime()
var date=new Date();
console.log(date.valueOf());
console.log(date.getTime());
//2.+new Date()
var date1=+new Date();
console.log(date1);
//3.
console.log(Date.now());

倒计时效果（时间戳来做）

function countDown(time)
{
    var nowTime=+now Date();
    var inputTime=+now Date(time);
    var times=(inputTime-noeTime)/1000;//剩余总的时间秒数
    var d=parseInt(times/60/60/24);//天
    var h=parseInt(times/60/60%24);//时
    var m=parseInt(times/60%60)//分
    var s=parseInt(times%60)
    return d+'天'+h+'时'+m+'分'+s+'秒'; 
}

3)数组对象

//1.数组字面量创建
var arr =[1,2,3];
console.log(arr[0]);
//2.new Array()创建
//var arr1=new Array();//创建了一个空数组
//var arr1=new Array(2);//数组的长度为2，里面有两个元素
var arr1=new Array(2,3)//等价与[2,3]


//检测是否为数组
//(1)instanceof 运算符检测
console.log(arr instanceof Array);//结果为true
  //(2)
console.log(Array.isArray(arr))

//添加数组元素
var arr =[1,2,3];
arr.push(4);//末尾增加,push完毕后返回的结果是新数组的长度，
arr.unshift(4);//开头添加，unshift完毕后返回的结果是新数组的长度，
arr.pop();//pop没有参数，删除数组最后一个元素，返回结果是删除的那个元素
arr.shift();//shift没有参数，删除数组第一个元素，返回第一个元素的值

//数组排序
//1.翻转数组
var arr1=['a','b','c'];
arr.reverse();
//2.数组排序
var arr2=[1,4,2,3];
arr2.sort(function(a,b){
    return a-b;//升序排序，b-a降序排序；
});