JavaScript基础 DATE Math 字符串

Posted 2021-09-24 HUMILITY

函数的方法

这两个方法都是函数对象的方法，需要通过函数对象来调用
this的情况：
1.以函数形式调用时，this永远都是window
2.以方法形式调用，this时调用方法的对象
3.以构造函数形式调用时，this时新创建的那个对象
4.使用call和apply调用时，this时指定的那个对象

function fun (){
    alert("我是fun函数")
}

当对函数调用call()和apply()都会调用函数执行

fun();                        //我是fun函数
fun.apply();                //我是fun函数
fun.call();                    //我是fun函数

在调用call()和apply()可以将一个对象指定为第一个参数
此时这个对象将会成为函数执行时的this

function fun (){
    alert(this)
}
var obj = {};
fun();                        //object window
fun.call(obj);                //object Object
fun.apply(obj);                //object Object


function fun (){
    alert(this.name)
}
var obj = {name:"obj"};
var obj2 = {name:"obj2"};
fun.apply(obj);                //obj
fun.apply(obj2);            //obj2

function fun (){
    alert(this.name)
}
var obj = {
    name:"obj"
    sayName:function(){
        alert(this.name);
    }
};
var obj2 = {
    name:"obj2"
};

obj.sayName();                            //obj
obj.sayName.apply(obj2);                //obj2

call()可以将实参在对象之后依次传递

function fun (a,b){
    console.log("a="+a);
    console.log("b="+b);
}
var obj = {name:"obj"};
var obj2 = {name:"obj2"};
fun.call(obj,2,3);                        //a=2 b=3

apply()方法需要将实参封装到一个数组中统一传递

fun.apply(obj,[2,3]);                    //a=2 b=3

arguments

在调用函数时，浏览器每次都会传递进两个隐含的参数，
1.函数的上下文对象this
2.封装实参的对象arguments
arguments时一个类数组对象，它也可以通过索引来操作数据，也可以获取长度
在调用函数时，我们所传递的实参都会在arguments中保存
arguments.length可以用来获取实参的长度
我们即使不定义形参，也可以通过arguments来使用实参
只不过比较麻烦
arguments[0] 表示第一个实参
arguments[1] 表示第二个实参
它里面有一个属性叫做callee
这个属性对应一个函数对象，就是当前正在指向的函数的对象

function fun(){
    console.log(arguments instanceof Array);          //false
    console.log(Array.isArray(arguments));            //false
    console.log(arguments[1]);                        //true
    console.log(arguments.length);                    //2
    console.log(arguments.callee);                    //当前正在指向的函数的对象
}
fun();
fun("hello",true);                                    //2

Date对象

在JS中使用Date对象来表示一个时间
如果直接使用构造函数创建一个Date对象。则会封装为当前代码执行的时间

var d = new Date();

console.log(d);

创建一个指定的时间对象
需要在构造函数中传递一个表示时间的字符串作为参数
日期的格式： 月份/日/年 时:分:秒

var d2 = new Date("03/10/2021 11:11:30");

console.log(d2);

getDate() 获取当前日期对象是几日

var date = d2.getDate()

console.log("date="+date);                        //10号

getDay() 获取当前日期对象是周几，会返回一个0-6的值，0表示周日，1-6周一到周六

var day = d2.getDay()

console.log("day="+day);                        //周六

getMonth() 获取当前时间对象的月份，会返回一个0-11的值，0表示一月，1-11表示二到十二月

var month = d2.getMonth();

console.log("month="+month);                    //2（表示三月）
console.log("month="+(month+1));                //3进行转换为中国月

getFullYear() 获取当前日期对象的年份

var year = d2.getFullYear;

console.log(year);                                //2021

getTime() 获取当前日期对象的时间戳,
时间戳指的是从格林威治标准时间的1970年1月1日，0点0时0分0秒
到当前日期所花费的毫秒数（1秒=1000毫秒）
计算机底层在保存时间使用的都是时间戳

var time = d2.getTime();

console.log(time);    

var d3 = new Date("1/1/1970 0:0:0");
time = d3.getTime();
console.log(time);                                //-28800000中国时区所以负值还没到d3时间（-8小时）

获取当前的时间戳

time = Date.now();
console.log(time);

可以利用时间戳测试代码的执行的性能

var start = Date.now();
for(var i=0 ; i<100; i++){
    console.log(i)
}
var end = Date.now();

console.log("执行了"+(end - start)+"毫秒");

Math

Math和其他的对象不同，不是一个构造函数，
它属于一个工具类不用创建对象，它里边封装了数学运算相关的属性和方法
Math.PI 用来表示圆周率

abs()可以用来计算一个数的绝对值

console.log(Math.abs(-1));                        //1

Math.ceil() 可以对一个数进行向上取整，小数位只要有值就自动进一

console.log(Math.ceil(1.4));                    //2

Math.floor() 可以对一个数进行向下取整小数部分会被舍掉

console.log(Math.floor(1.99));                    //1

Math.round() 可以对一个数进行四舍五入取整

console.log(Math.round(1.4));                    //1

Math.random() 可以用来生成一个0-1之间的随机数

console.log(Math.random());

生成一个0-x之间的随机数

Math.round(Math.random()*x);

生成0-10的随机数

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

生成一个x-y之间的随机数

console.log(Math.round(Math.random()*(y-x))+x);

生成一个1-10之间的随机数

console.log(Math.round(Math.random()*9)+1);

生成一个1-6之间的随机数

console.log(Math.round(Math.random()*5+1));

max() 可以获取多个数中的最大值

var max = Math.max(10,20,30);
console.log(max);                            //30

min() 可以获取多个数中的最小值

var min = Math.min(10,20,30);
console.log(min);                            //10

Math.pow(x,y) 返回x的y次幂

console.log(Math.pow(3,2))                    //9

Math.sqrt() 用于对一个数进行开方运算

console.log(Math.sqrt(2))                          //1.4142135623730951

包装类

在JS中为我们提供了三个包装类，通过这三个包装类可以将基本数据类型的数据转换为对象
1.String()
可以将基本数据类型字符串转换为String对象
2.Number()
可以将基本数据类型的数字转换为Number对象
3.Boolean()
可以将基本数据类型的布尔值转换为Boolean对象
但是注意：我们在实际应用中不会使用基本数据类型的对象
如果使用基本数据类型的对象，再做一些比较时可能会带来一些不可预期的结果
方法和属性只能添加给属性，不能添加给基本数据类型
当我们对一些基本数据类型的值去调用属性和方法时，
浏览器会临时使用包装类将其转换为对象，然后在调用对象的属性和方法
调用完之后，再将其转换为基本数据类型

字符串的方法

var str = "Hello World"

在底层字符串是以字符数组的形式保存的
["H","e","l"]
length属性
可以用来获取字符串的长度

console.log(str.length);                    //11
console.log(str[1]);                        //e

charAt()
可以返回字符串中指定位置的字符
根据索引获取指定的字符

var str = "Hello World"
var result = str.charAt(0);                    //H
var result = str[0];                        //H
console.log(result);

charCodeAt()
获取指定位置字符的字符编码（Unicode编码）

var result = str.charAt(0);                    //H
var result = str.charCodeAt(0);                //72

String.fromCharCode()
可以根据字符编码去获取字符

result = String.fromCharCode(72);
console.log(result);                        //H

十六进制的在前面加0x

result = String.fromCharCode(0x2682);        //⚂

concat()
可以用来连接两个或多个字符串
作用和+一样

var str = "Hello World"
result = str.concat("你好","再见");
console.log(result);                        //Hello World你好再见

indexOf()
该方法可以检索一个字符串中是否含有指定内容
如果字符串中含有该内容，则会返回其第一次出现的索引
如果没有找到指定的内容，则返回-1

str = "Hello World";
result = str.indexOf("0");            
console.log(result);                            //-1
result = str.indexOf("l");            
console.log(result);                            //2

可以指定第二个参数，指定开始查找的位置

result = str.indexOf("l",4);        
console.log(result);                            //9    

lastIndexOf()存疑
该方法的用法和indexof()一样
不同的是indexOf是从前往后找
而lastIndexOf是从后往前找

str = "Hello World";
result = str.lastIndexOf("l");            
console.log(result);                            //9

可以指定第二个参数，指定开始查找的位置

result = str.lastIndexOf("l",4)    ;        
console.log(result);                            //3

slice()
可以从字符串中截取指定的内容
不会影响原字符串，而是将截取到的内容返回
参数：
第一个：开始位置打的索引（包括开始位置）
第二个：结束位置的索引（不包括结束位置）如果省略第二个参数则会截取到后边所有的
也可以传递一个负数作为参数，负数的话将会从后边计算

str = "abcdefghijk";
result = str.slice(1,4);
console.log(result);                            //bcd

substring()
可以用来截取一个字符串，与slice()类似
参数：
第一个：开始截取位置的索引（包括开始位置）
第二个：结束位置的索引（不包括结束位置）
不同的是这个方法不能接受负值作为参数，如果传递了一个负值，则默认使用0
而且会自动调整参数的位置，如果第二个参数小于第一个，则自动交换

str = "abcdefghijk";
result = str.substring(1,4);
console.log(result);                            //bcd

substr()
用来截取字符串
参数：
1.截取开始位置的索引
2.截取的长度

str = "abcdefghijk";
result = str.substr(3,2);
console.log(result);                            //de

split()
可以将一个字符串拆分为一个数组
参数：需要一个字符串作为参数，将会根据该字符串去拆分数组

str = "abc,bcd,efg,hij";
result = str.split(",")
console.log(typeof result);

console.log(result[1]);                            //bcd
console.log(result.length);                        //4


result = str.split("d");
console.log(result.length);                        //2

如果传递一个空串作为参数，则会将每个字符都拆分为数组中的一个元素

str = "abcbcde";
result = str.split("")
console.log(result);                        // "a", "b","c","b","c","d","e"

toUpperCase()
将一个字符串转换为大写并返回，不会影响到原变量

str = "abcdefg";
result = str.toUpperCase();
console.log(result);                            //ABCDEFG

toLowerCase()
将一个字符串转换为小写并返回，不会影响到原变量

str = "ABCDEFG";
result = str.toLowerCase();
console.log(result);                            //abcdefg