JavaScript学习笔记——JS基础8

80arguments

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            // 在调用函数时，浏览器每次都会传递俩个隐含的参数，
            // 1.函数的上下文对象this
            // 2.封装实参的对象arguments
            //         arguments是一个类数组对象,它也可以通过索引来操作数据，也可以获取长度
            //         在调用函数时，我们传递的实参都会在arguments中保存
            //         arguments.length可以用来获取实参的长度
            //         我们即使不定义形参，也可以通过arguments来使用实参，
            //         只不过比较麻烦
            //         arguments[0] 表示第一个实参
            // 它里边有一个属性叫callee;
            //         这个属性对应一个函数对象，就是当前正则指定的函数的对象
            function fun(a,b){
                // console.log(arguments instanceof Array);
                // console.log(Array.isArray(arguments));
                // console.log(arguments.length);
                // console.log(arguments[0]);
                console.log(arguments.callee==fun);
            }
            fun("hello",true);
        </script>
    </head>
    <body>
    </body>
</html>

  

81Date对象

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        
    </head>
    <body>
        <script>
            // Data对象
            /*
                在JS中使用date对象来表示一个时间
            */
           // 创建一个data对象
           // 如果直接使用构造函数创建一个Date对象，则会封装为当前代码执行的时间
           var d=new Date();
           // 创建一个指定的时间
           // 需要在构造函数中传递一个表示时间的字符串作为参数
           // 日期的格式 月份/日/年 时：分：秒
           var d2=new Date("12/21/2016 11:10:30");
           // getDate()
           // 获取当前日期对象是几日
           var date=d2.getDate();
           // getDay()
           // 获取当前日期对象周几
           // 会返回一个0-6的值
           // 0表示周日 1表示周一
           var day=d2.getDay();
           var month=d2.getMonth();
           // getMonth()
           // 可以获取当前时间对象的月份
           // var d2=new Date("12/21/2016 11:10:30");
           // 会返回一个0-11的值
           // 0表示1月 1表示2月
           // console.log(month+1);
           var year=d2.getFullYear();
           // getFullYear
           // 获取当前日期对象的年份
           // 不要使用getYear()方法，getYear()是返回缩写，有异常。如果返回16，不确定是2016还是1916
           // console.log(year);
           // getTime（）
           // 获取当前对象的时间戳
           // 时间戳，指的是从格林威治标准时间的1970年1月1日，0时0份0秒
           // 到当前日期所花费的毫秒数（1秒=1000毫秒）
           // 计算机底层在保存时间时使用都是时间戳
           var time=d.getTime();
           // console.log(time/1000/60/60/24/365);转换为现在到1970年过了多少
           // var d3=new Date("1/1/1970 0:0:0");
           // time=d3.getTime();
           // 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);
        </script>
    </body>
</html>

82Math

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            // Math
            // Math和其他的对象不同，它不是一个构造函数，
            // 它属于一个工具类不用创建对象，它里边封装了数学运算的属性和方法
            // 比如
            //         Math.PI    表示圆周率
            // console.log(Math.PI);
            // abs()可以用来计算一个数的绝对值
            // console.log(Math.abs(-1));
            // Math.ceil()
            // 可以对一个数进行向上取证，小数位只有有值，就自动进一
            // console.log(Math.ceil(1.1));2
            // Math.floor()
            // 向下取证，小数部分会被舍掉
            // console.log(Math.floor(1.9))1
            // Math.round()
            // 四舍五入取整
            // console.log(Math.round(1.9))
            // Math.random())
            // 可以随机生成0-1的随机数
            // 生成一个0-10的随机数
            // 生成一个0-X的随机数
            // Math.round(Math.random()*X)
            // console.log(Math.random())
            // 生成1-10;
            // 生成一个x-y之间的随机数
            // Math.round(Math.random()*y-x)+x)
            // for(var i=0;i<100;i++){
            //     // console.log(Math.round(Math.random()*10))
            //     console.log(Math.round(Math.random()*9)+1);
            // }
            // max()获取多个数中的最大值
            // min()获取多个数中的最小值
            var max=Math.max(10,20,30);
            // console.log(max);
            // Math.pow(x,y)
            // 返回x的y次幂
            // Math.sqrt
            // 用于对一个数进行开方运算
            console.log(Math.pow(2,3));8
            console.log(Math.sqrt(2));
        </script>
    </head>
    <body>
    </body>
</html>

83包装类

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            // 基本数据类型
            // String Number BOOlean Null Undefined    
            // 引用数据类型
            // Object
            // 在JS中我们提供了三个包装类，通过这三个包装类    可以将基本数据类型转换为对象
            // String()
                // 可以将基本数据类型字符串转换为String对象
            // Number()
                // 可以将基本数据类型数字转换为Number对象
            // BOOlean()
                // 可以将基本数据类型布尔值转换为BOOlean对象    
                // 但是注意，我们在实际应用中不会使用基本数据类型的的对象
                // 如果使用基本数据类型的对象，在做一些比较可以会带来一些不可预习的结果
            var num=new Number(3);
            var str=new String("hello");
            var bool=new Boolean(true);
            console.log(typeof num);
            // 向num中添加一个属性    
            num.hello="dsdsdsdd";
            console.log(num.hello);
            // 方法和属性只能添加给我们的对象    ，不能添加给基本数据类型            
            // 当我们对一些基本数据类型的值去调用属性和方法时。
            // 浏览器会临时使用包装类将其转换为对象，然后在调用对象的属性和方法
            // 调完后，将其转换为基本数据类型
            var s=123;
            s=s.toString();
            s.hello="你好";
            console.log(s);
            console.log(typeof s);
            console.log(s.hello);
        </script>
    </head>
    <body>
    </body>
</html>

84字符串的方法

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            // 创建一个字符串
            var str="hello";
            // 在底层字符串是以字符数组的形式保存的
            // ["h","e","l"]
            
            // length 属性
                    // 可以用来获取字符串的长度
            // console.log(str.length)
            // charAt()
            // 返回字符串指定字符的字符
            // 根据索引获取指定的字符
            // console.log(str.charAt(2));l
            // charCodeAt()
            // 获取指定位置字符的字符编码(Unicode编码)
            // var result=str.charCodeAt(1);72
            // console.log(result);
            // String.formCharCode()
            // 可以根据字符编码去获取字符
            var result=String.fromCharCode(0x1272);
            console.log(result);
            // concat()
            // 可以用来连接俩个或多个字符串
            // 作用和+一样
            result=str.concat("你好","sss");
            console.log(result)
            // indexof()
            // 该方法可以检索一个字符串中是否含有指定内容
            // 如何字符串中含有该内容，则会返回其第一次出现的索引
            // 如果不存在就返回-1
            // 可以指定一个第二个参数，指定开始查找的位置
            // lastindexOf()
            // lastIndexOf() 方法可返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。
            var str="hello hatguigu";
            // result=str.indexOf("s",6);s
            result=str.lastIndexOf("g");
            // slice()
            // 可以从字符串中截取指定的内容
            // 参数：
            // 第一个为开始位置的索引，包括开始位置
            // 第二个为结束位置的索引，不包括结束位置
            // 如果我们省略第二个参数，会截取到后边的所有的
            // 也可以传递一个负数作为参数，负数的话就会从后边开始计算
            str="afasfasfasfas"
            result=str.slice(0,-2)
            // substring()
            // 可以用来截取一个字符串，和slice类型
            // 参数
            // 第一个，开始截取位置的索引，包括开始位置
            // 第二个为结束位置的索引，不包括结束位置
            //不同的是这个方法不能接受负值作为参数，
            // 如果传递了一个负值，则默认使用0
            // 而且他还自动调整参数的位置，如果第二个参数小于第一个，则自动交换
            result=str.substring(2,-2)
            // 等同于result=str.substring(0,2)
            result=str.substr(3,4)
            // substr()
            // 用来截取字符串
            // 参数
            // 1.截取开始位置的索引
            // 2.截取数量
            // split()
            // 可以将一个字符串拆分为一个数组
            str="abc,sdn,wwwe,kkk";
            result=str.split(",")
            // 如果传入一个空串作为参数，则会将每个字符拆分为字符中的元素    
            result=str.split("");
            console.log(result.length);
            // toUpperCase()将字符串转换为大写并返回
            // toLowerCase()将字符串转换为小写并返回
            console.log(str.toUpperCase()); 
        </script>
    </head>
    <body>
    </body>
</html>

85正则表达式的简介

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            // 正则表达式
            // admin
            // admin@qq.com
            // 邮件的规则：
            // 1。前边可以是XXX乱七八遭
            // 2.跟着一个@
            // 3.后面可以是XXXX乱七八遭
            // 4.。com获取其他的乱七八糟
            
            // 正则表达式用于定义一些字符串的规则
            // 计算机可以根据正则表达式，来检查一个字符串是否符合规则
            // 或者将字符串中符合规则的内容提取出来
            // 创建正则表达式对象
            // 语法
            // var 变量=new RegExp("正则表达式","    匹配模式")
            // var reg=new RegExp("a");这个正则表达式可以来检查一个字符串是否含有a
            // 在构造函数中可以传递一个匹配模式作为第二个参数
            // 可以是
            //         i忽略大小写
            //         g全局匹配模式
            var reg=new RegExp("a","i");
            var str="a";
            // 正则表达式的方法
            // test()
            // 使用这个方法可以用来检测一个字符串是否符合正则表示的规则
            // 如果符合就返回true，否则返回false
            var result=reg.test(str);
            // console.log(result)
            console.log(reg.test("AAA"));    
        </script>
    </head>
    <body>
    </body>
</html>

86正则语法

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            // 使用字面量来创建正则表达式
            // 语法：var 变量=/正则表达式/匹配模式    
            // 使用字面量的方式创建更加简单
            // 使用构造函数创建更加灵活
            var reg=/a/i;
            // console.log(reg.test("AAAA"));
            // 创建一个正则表达式，检查一个字符串中是否有a或者b
            // 使用 |表示或者的意思
            reg=/a|b/;
            console.log(reg.test("acb"))
            // 创建一个正则表达式检查一个字符串中是否有字母
            // []里的内容也是或的关系
            // 【ab】==a|b
            // [a-z]任意小写字母
            // [A-Z]任意大写字母
            // [A-z]任意字母
            // [0-9]任意数字
            reg=/[A-z]/
            // 检查一个字符串中是否含有abc或adc或aec
            reg=/a[bde]c/
            // [^ ] 除了括号之间的
            reg=/[^ab]/;
            reg=/[^0-9]/
            console.log(reg.test("123    "));
        </script>
    </head>
    <body>
    </body>
</html>

87字符串和正则相关的方法

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            var str="1adsd233cs";
            // split()
            // 可以将一个字符串拆分为一个数组
            // 方法中可以传递一个正则表达式作为参数，这样会根据正则表达式来拆分字符串
            // 根据任意字母来将字符串拆分
            // 这个方法即使不指定全局匹配，也会全部拆分
            var result=str.split(/[A-z]/);
            // search
            // 可以搜索字符串中是否含有指定内容
            // 如果搜索到指定内容，则会返回第一次出现的索引，如果没有搜索就返回-1
            // 它接收一个正则表达式作为参数，然后根据正则表示式来检索字符串
            // serach()只会查找第一个，即使设置全局也没有用
            str="hello abc hello dfc"
            // 搜索字符串中是否含有abc 或 aec 或afc
            result=str.search(/a[bef]c/)
            // match()
            // 可以根据正则表达式，从一个字符串中将符合条件的内容提取出来
            // 默认情况下我们的match只会找到第一个符合要求的内容，找到以后就停止检索
            // 我们可以设置正则表示式为全局匹配模式，这样就会匹配到所有的内容
            //    可以为一个正则表达式设置多个匹配模式，且顺序无所谓
            // match()会将匹配到的内容封装到一个数组中返回，即使只查询一个结果
            str="1a2h23h3g34k54h54uh5"
            result=str.match(/[A-z]/ig);
            console.log(result[2])
            // replace()
            // 可以将字符串中指定的内容替换为新的内容
            // 参数：
            // 1.被替换的内容，可以接收一个正则表示式为参数
            // 2.新的内容
            // 默认只会替换第一个
            // 使用“”就是删除
            result=str.replace(/h/ig,"");
            console.log(result);
        </script>
    </head>
    <body>
    </body>        
</html>

88正则表达式语法

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            // 创建一个正则表达式检查一个字符串是否含有aaa
            // 量词
            // 通过量词可以设置一个内容出现的次数
            // 量词只对它前边的一个内容起作用
            // {n} 正好出现n次
            // {m,n}出现m-n次
            // {m,}m次以上
            // +至少一个，相当于{1,}
            // *表示0个或多个，相当于{0,}
            // ?表示0个多1个,相当于{0,1}
            var reg=/a{3}/;
            // ababab
            reg=/(ab){3}/
            reg=/ab{1,3}c/
            reg=/ab+c/
            reg=/ab*c/
            reg=/ab?c/
            console.log(reg.test("abbcc"));    
            // 检查一个字符串是否以a开头
            // ^表示开头
            // $表示结尾
            // 如果在正则表达式中同时使用^$则表示字符串必须完全符合正则表达式
            reg=/^a/;
            reg=/a$/;
            reg=/^a$/;
            reg=/^a|a$/;
            console.log(reg.test("aaa"));
            // 创建一个正则表达式，来检查一个字符串是否为一个合法的手机号
            // 手机号规则
            // 13627819280 11位
            // 1.以1开头
            // 2.第二位不能是3-9的任意数字
            // 3.三位以后任意数字9个
            // ^1 [3-9] [0-9]{9}$
            var phoneStr="13627819280"
            var phoneReg=/^1[3-9][0-9]{9}$/
            console.log(phoneReg.test(phoneStr));
        </script>
    </head>
    <body>
    </body>
</html>

89正则表达式语法

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            // 检查一个字符串中是否有.
            // .表示任意字符
            //在正则表达式中使用\表示转义字符
            // \.表示.
            // \\表示\
            // 注意使用构造函数时，由于它的一个参数是一个字符串，而\是字符串中转义字符
            // 如果要使用\则需要使用\\来代替
            var reg=/\./;
            // reg=/\\/
            reg=new RegExp("\.")
            console.log(reg.test("abcbcd.\\"));
            // console.log(reg);
            // \w
            // 任意字母,数字，_    [A-z0-8_]
            // \W 
            // 非任意字母,数字，_      [^A-z0-8_]
            // \d
            // 任意数字[0-9]
            // \D
            // 任意非数字[^0-9]
            // \s
            // 空格
            // \S
            // 除了空格
            // \b
            // 单词边界
            // \B
            // 除了单词边界
            reg=/\w/
            reg=/\W/
            reg=/\d/
            reg=/\D/
            reg=/\s/
            reg=/\S/
            // 创建一个正则表达式检查一个字符串中是否含有单词child
            reg=/\bchild\b/
            // 要前后都加\b
            // console.log(reg.test("hello child ren"));
            // 接收一个用户的输入
            // var str=prompt("请输入你的用户名");
            str="     hel       lo     "
            // 去除字符串中前后的空格
            // 去除空格就是使用“”来替换空格
            // 去除前边的空格
            // 去除开头的空格
            // str=str.replace(/^\s*/,"")
            // 去除结尾的空格
            // str=str.replace(/\s*$/,"")
            // /^\s*/ /\s*$/
            // /^\s*|\s*$/g匹配开头结尾的空格
            str=str.replace(/^\s*|\s*$/g,"")
            console.log(str);
        </script>
    </head>
    <body>
    </body>
</html>

版权声明：本文为weixin_64612659原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。