js基础第六天

实现系统的Max的方法

function Math() {
        this.getMax = function() {
            var max = arguments[0];
            for (var i = 0; i < arguments[i]; i++) {
                if (max < arguments[i]) {
                    max = arguments[i];
                }
            }
            return max;
        }
    }
    var mt = new Math();
    max = mt.getMax(10, 50, 80, 90);
    console.log(max);

Date

//    var dt=new Date();
    //    //当前的时间---当前的服务器
    //    console.log(dt);

这个输出的是当前时间

var dt = new Date(“2017/12/8”);

var dt = new Date(“2017-12-8”);

有传入时间那么输出的就是传入的时间类型

获取当前时间对象  毫秒
// var dt = Date.now();
    // console.log(dt);

    //    var dt = new Date();
    //
    //    //获取年份
    //    console.log(dt.getFullYear());
    //    //获取月份
    //    console.log(dt.getMonth()+1);//是0开始的 真实的月份是需要加1的
    //    //获取日期
    //    console.log(dt.getDate());
    //    //获取小时
    //    console.log(dt.getHours());
    //    //获取分钟
    //    console.log(dt.getMinutes());
    //    //获取秒
    //    console.log(dt.getSeconds());
    //
    //    //获取星期
    //    console.log(dt.getDay());//星期从0开始的


    // var dt=new Date();

    //console.log(dt.toDateString());//英文的---日期
    //console.log(dt.toLocaleDateString());//数字格式--日期

    //    console.log(dt.toTimeString());//小时分钟秒
    //    console.log(dt.toLocaleTimeString());//小时分钟秒

    //console.log(dt.valueOf());//毫秒值
    //    console.log(dt);
    //    //转成字符串
    //    console.log(dt.toString());

    //    var num=10;
    //    console.log(num.toString());

Date总结

   //var dt=new Date();
//    var dt=+new Date();//一种特殊的写法,只适用于这个Date的对象
//    console.log(dt);

//    dt.getFullYear();//年
//    dt.getMonth();//月---从0开始
//    dt.getDate();//日
//    dt.getHours();//小时
//    dt.getMinutes();//分钟
//    dt.getSeconds();//秒
//    dt.getDay();//星期---从0开始
//    dt.toDateString();//日期
//    dt.toLocaleDateString();//日期
//    dt.toTimeString();//时间
//    dt.toLocaleTimeString();//时间
//    dt.valueOf();//毫秒

console.log(dt.toLocaleDateString());得到的是一个数字类型的日期 2019/2/5

console.log(dt.toTimeString()); 10:29:38 小时 分 秒

console.log(dt.toLocaleTimeString()); //小时分钟秒 上午10:30:27

获取指定格式日期的函数

/**
 * Created by Administrator on 2017-09-13.
 */
//格式化后的指定格式的日期和时间---封装一个函数

/**
 * 获取指定格式的时间
 * @param dt 日期的对象
 * @returns {string} 返回的是字符串的日期时间
 */
function getDate(dt) {
    //获取年
    var year = dt.getFullYear();
    //获取月
    var month = dt.getMonth() + 1;
    //获取日
    var day = dt.getDate();
    //获取小时
    var hour = dt.getHours();
    //获取分钟
    var minute = dt.getMinutes();
    //获取秒
    var second = dt.getSeconds();
    month = month < 10 ? "0" + month : month;
    day = day < 10 ? "0" + day : day;
    hour = hour < 10 ? "0" + hour : hour;
    minute = minute < 10 ? "0" + minute : minute;
    second = second < 10 ? "0" + second : second;
    return year + "年" + month + "月" + day + "日 " + hour + ":" + minute + ":" + second;
}

String 字符串

     * 实例方法---->必须要通过new的方式创建的对象(实例对象)来调用的方法
     * 静态方法---->直接通过大写的构造函数的名字调用的方法(直接通过大写的对象名字调用的)
     *
     * */
    /*
     *
     * 字符串的常用属性:
     * .length------>字符串的长度
     * .charAt(索引),返回值是指定索引位置的字符串,超出索引,结果是空字符串
     * .fromCharCode(数字值,可以是多个参数),返回的是ASCII码对应的值
     * .concat(字符串1,字符串2,...);返回的是拼接之后的新的字符串
     * .indexOf(要找的字符串,从某个位置开始的索引);返回的是这个字符串的索引值,没找到则返回-1
     * .lastIndexOf(要找的字符串);从后向前找,但是索引仍然是从左向右的方式,找不到则返回-1
     * .replace("原来的字符串","新的字符串");用来替换字符串的
     * .slice(开始的索引,结束的索引); 从索引5的位置开始提取,到索引为10的前一个结束,没有10，并返回这个提取后的字符串
     * .split("要干掉的字符串",切割后留下的个数);切割字符串
     * .substr(开始的位置,个数);返回的是截取后的新的字符串
     * .substring(开始的索引,结束的索引),返回截取后的字符串,不包含结束的索引的字符串
     * .toLocaleLowerCase();转小写
     * .toLowerCase();转小写
     * .toLocaleUpperCase()转大写
     * .toUpperCase();转大写
     * .trim();干掉字符串两端的空格

命名函数

function f1(){

}

构造函数

function Person(){

}

string 字符串类型 基本类型 小写得s

String 字符串类型 引用类型 大写得S

大写S String 字符串对象 构造函数

js没有字符类型 int num = 10；

js都用 var 字符串 用 “” 或者 ‘’

字符串不可变性

 var str = "hello";
 str[1] = "W";
 console.log(str);
 输出得结果是  hello  只读

通过索引 改变字符串里面得值 是不能改变得 重新赋值可以改变

但是只是指向发生改变

字符串当作数组 循环遍历输出

 var str = "hello";
    for (var i = 0; i < str.length; i++) {
        console.log(str[i]);
    }

字符串的相关方法

#####charAt 返回的是指定索引的字符串 超出索引，结果是空字符串

  var str = "what";
    var b = str.charAt(2);
    console.log(b);
    输出的是 索引为2  的a

静态方法 案例

String.formCharCode(10，20) 返回的unicode码 不能通过str对象点出来

unicode码和Ascii码相反 一个返回字母 一个数字

字符串拼接 concat

str = "123";
    str1 = "456";

 console.log(str.concat(str1));

concat 可以传入多个参数 返回的是新的字符串

indexOf 方法 相当于查找一个字符串的索引 没找到 则返回 - 1

var str = "你好帅啊";
console.log(str.indexOf("帅"));

返回数字 2； 有重复的数字 则返回第一个找到符合的索引

第一个参数是 想要的字符串 第二个参数是 指定从某个位置开始找 包括这个指定位置

#####lastIndexOf 是从后面往前找 从右到左 但是返回的索引 正确

var str = "你好帅啊素帅";
console.log(str.lastIndexOf("帅"));
输出的也是5
索引仍然是从左往右找

用法 和 indexOf 差不多 但是只有一个参数

#####正则匹配

str.match(regexp);

replace替换

 var str = "xiaoshu好书";
 console.log(str.replace("书", "帅"));

slice方法 截取 不包含结束位置

提取字符串的一部分，并返回一个新的字符串

两个参数 第一个参数 截取的起始位置 第一个参数 结束位置 不包含结束的位置

var str = "如果有一台你,计算机视觉就";
    str = str.slice(2, 6);
    console.log(str);

split() 字符串的切割

var str = "乔峰|慕容|凤姐|梅超风|小苏|大蛇丸";
var arr = str.split("|"); 
console.log(arr);

按 | 切割 切割后 变成了一个数组 | 就不存在了

substr方法 截取

一个参数代表 从某个位置开始截取 比如3 包括3这个位置

两个参数代表 某个位置 然后 截取几个的意思

substring 截取 不包含结束

两个参数 从拿开是截取到哪里结束 不包含结束索引的字符串

var str = "哈哈哈,真的好帅";
console.log(str.substring(5, 6));

tolocaleLowerCase 转换为小写 toLowerCase

 var str = "HELLO";
 console.log(str.toLocaleLowerCase());

toUpperCase toLocaleUpperCase 转大写

trim 去掉空字符串 干掉两边的空白符

只能去掉左边的

trimLeft 去掉左边

trimRight 去掉右边

var str = "   hello  pp";
console.log(str.replace(/\s/g, ""));

这个可以去掉所有的空白符

字符串案例 输出 o 出现所有位置的索引

var str2 = "hello wod odd ott fbo nhyo";
    var index = 0;
    var key = "o";
    while ((index = str2.indexOf(key, index)) != -1) {
        console.log(index);
        index += key.length;
    }

  console.log(index);
  key.length 比如要找的是一个o 则长度为1  如果  要找“您好”  则长度为2   意思找到了  就跳过这两个

案例3:找到这个字符串中每个字符串出现了多少次

结果是知道每个字母出现了多少次

// //案例3:找到这个字符串中每个字符串出现了多少次
    // var str3 = "whatOareYyouYnoYshaHleiHoHmyHgod";
    // //第一步:把所有的字母全部变成小写
    // str3 = str3.toLocaleLowerCase();
    // //第二步:创建一个空对象,目的:把字母作为键,次数作为值
    // var obj = {};
    // //第三步,遍历字符串,获取每个字母
    // for (var i = 0; i < str3.length; i++) {
    //   //判断obj这个对象中有没有这个字母(字母---键)
    //   var key = str3[i];//每个字母
    //   if (obj[key]) {//判断obj中有没有这个键
    //     //对象中有这个字母了
    //     obj[key]++;
    //   } else {
    //     //对象中没有这个字母,那就把字母加到对象中,并且给这个字母一个出现的次数,默认1次
    //     obj[key] = 1;
    //   }
    // }
    
    // //遍历对象,显示每个字母的次数
    // for(var key in obj){
    //   console.log(key+"这个字母出现了"+obj[key]+"次");
    // }
    // //创建新的对象---空对象---没有属性,也没有方法

var key = str3[i];//每个字母 返回的是每个字符串 不是数组

var arr = str.split("|"); 切割返回的是数组

理解 当第一次if的时候 obj是空的 所以是obj[key] = 1 ;在循环的时候 有这个数字了 就开始obj

[key]++了 这时是一个数字可以相加了

扩展案例 做一下

typeof str 返回时类型 判断属于哪一个类型

instanceOf 返回的true或者false

####Array

判断传入的值是否时array

Array.isArray([10,20,30]);

arr = [10, 20, 30];

    console.log(Array.isArray(arr));

返回的时true或者false

Array.from 将一个数组赋予另外一个数组

var arr = ["a", "b", "c"];
var newArr = Array.from(arr);
console.log(newArr);

拼接数组 concat

var arr = [10, 20, 30];
var arr2 = [10, 20, 30, 40];
var arr = arr.concat(arr2);
console.log(arr);

arr.every() 可以用来帅选

var arr = [100,200,300];
arr.every(function (ele,index){
    return ele > 2000; //数组的每个元素都大于2000
})
a代表元素的值  b 代表元素的索引

返回值时 boolean值

如果数组每个元素都符合条件 则返回true

filter 返回符合条件元素

var arr = [10, 20, 30, 40, 50, 60, 70];
newArr = arr.filter(function(ele, index, array) {
    return ele > 40;
})
 console.log(newArr);

返回的值时一个新的数组 参数按需传入就可以了

过滤掉元素里面的0 元素 也可以使用这种方法

push() 追加一个元素到数组的最后面 返回值是追加数据之后的数组长度

var arr = [10, 20, 30, 40, 50, 60, 70];
arr.push(100);
console.log(arr);

pop() 删除数组的最后一个元素 返回值就是删除的这个值

var arr = [10, 20, 30, 40, 50, 60, 70];
arr.pop();
console.log(arr);

#####shift()删除数组中的第一个元素 返回值就是删除的这个值

unshift()插入一个新元素到数组的第一个元素 返回值就是插入后的程度

#####arr.forEach()循环 相当于for循环

var arr = [10, 20, 30, 40, 50, 60, 70];
    arr.forEach(function(ele, index) {
        console.log(ele + "====" + index);
})

在ie8里用过不了 可以在MDN官方文档里面查找相关的文档

#####indexOf查找索引 和string里面的indexOf差不多

join方法 返回的是一个字符串 和字符串里面的split相反

将数组 以某种方式进行进行合并成字符串

var arr = [10, 20, 30, 40, 50, 60, 70];
var str = arr.join("|");
//join("字符串");
console.log(str);

map方法

var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
console.log(roots);

map方法让numbers里面的元素都运用 了 Math.sqrt;方法

数组调用 就不用加(),也可以直接 Math.sqrt(9)直接传入某个数字

数组的反转 reverse()

var arr = [10, 20, 20, 30, 50];
arr.reverse();
console.log(arr);

sort 方法 进行排序 不稳定

var arr = [10, 20, 20, 30, 50];
arr.sort();
console.log(arr);

稳定版

    arr.sort(function (a,b) {
         if(a>b){
           return 1;
         }else if(a==b){
           return 0;
         }else{
           return -1;
         }
       });
       console.log(arr);

#####slice方法 从开始到结束 不包括结束 截取

var arr = [10, 20, 30, 40, 50];
var arr = arr.slice(1, 3); 
console.log(arr);

splice方法

在元素的具体某个位置插入元素

var arr = [10, 20, 30, 40, 50];
arr.splice(2, 0, "drum");
console.log(arr);
//第一个参数  索引  第二个 参数 0 代表 不删除原来的元素  插入新的元素
// 第二个参数 如果是1 则干掉原来的元素
//第二个参数 代表要删除的元素   
替换  删除  插入

#####基本包装类型

普通变量不能直接调用或者属性方法

对象可以直接调用属性和方法

//基本包装类型:本身是基本类型,但是在执行代码的过程中,如果这种类型的变量调用了属性或者是方法,那么这种类型就不再是基本类型了,而是基本包装类型,这个变量也不是普通的变量了,而是基本包装类型对象

对象&&true 那么结果就是 true

true&&对象 那么结果就是对象

//    var num=10;
//    var num2=Number("10");//转换,没有new---类型转换  
//    var num3=new Number("10");//基本包装类型

删除数组中重复的元素

Array.prototype.strip = function() {
        if (this.length < 2) return [this[0]] || [];
        var arr = [];
        for (var i = 0; i < this.length; i++) {
            arr.push(this.splice(i--, 1));
            for (var j = 0; j < this.length; j++) {
                if (this[j] == arr[arr.length - 1]) {
                    this.splice(j--, 1);
                }
            }
        }
        return arr;
    }
    var arr = ["abc", 85, "abc", 85, 8, 8, 1, 2, 5, 4, 7, 8];
    alert(arr.strip());

数组总结

* Array.isArray(对象)---->判断这个对象是不是数组
     * instanceof关键字
     * .concat(数组,数组,数组,...) 组合一个新的数组
     * .every(函数)--返回值是布尔类型,函数作为参数使用,函数中有三个参数,第一个参数是元素的值，第二个参数是索引值,第三个参数是原来的数组(没用)
     * 如果这个数组中的每个元素的值都符合条件,最后才返回的是true
     *
     * .filter(函数);返回的是数组中每一个元素都复合条件的元素,组成了一个新的数组
     *
     * .push(值);--->把值追加到数组中,加到最后了---返回值也是追加数据之后的数组长度
     * .pop();--->删除数组中最后一个元素,返回值就是删除的这个值
     * .shift();--->删除数组中第一个元素,返回值就是删除的这个值
     * .unshift();--->向数组的第一个元素前面插入一个新的元素,----返回值是插入后的程度
     * .forEach(函数)方法---遍历数组用---相当于for循环
     * .indexOf(元素值);返回的是索引,没有则是-1
     * .join("字符串");----返回的是一个字符串
     * .map(函数);--->数组中的每个元素都要执行这个函数,把执行后的结果重新的全部的放在一个新的数组中
     * .reverse();----->反转数组
     * .sort();---排序的,可能不稳定,如果不稳定,请写MDN中的那个固定的代码
     * .arr.slice(开始的索引,结束的索引);把截取的数组的值放在一个新的数组中,但是不包含结束的索引对应的元素值
     * .splice(开始的位置,要删除的个数,替换的元素的值);一般是用于删除数组中的元素,或者是替换元素,或者是插入元素