JS学习笔记2

日期

• new Date()
• new Date(year,month,day,hour,minute,second,millisecond)
• new Date(millisecond)
• new Dtae(datestr)
  第二个构造函数后面的可以选填，但是必须有年和月，不能只有一个参数，否则就被识别为第三个构造函数
  第二个构造参数中的年如果为两位数或者一位数，则认为是19xx开头的

toUTCString（）：转化成0时区标准的时间字符串
toDateString():转化成更加易读的形式

<script>
            var date1=new Date();
            var date2=new Date(2023,1,1,23,54,22,0);
            var date3=new Date(99,1);
            var date4=new Date(100000);
            document.write(date1+"<br>");
            document.write(date2+"<br>");
            document.write(date3+"<br>");
            document.write(date4+"<br>");
            document.write(date1.toDateString()+"<br>");
            document.write(date1.toUTCString()+"<br>");
        </script>

第四种的参数为日期字符串，需要满足一定格式

ISO:yyyy-MM-ddThh:mm:ss
注意中间有个T，分隔日期和时间

获取部分日期参数

注意：获取的month和day是从0开始的

设置日期参数

JS数学函数

总体和java差不多，都是由Math类的静态调用

JS的特殊比较运算符

===和 !==
三个等号表示，当两个var类型和内容相等时才会返回true，否则为false，可以看作是对两个等号的更精确的说明
比如：

<script>
            var str=new String("hello");
            var str2="hello";
            document.write(str===str2+"<br>");
            
        </script>

返回false，因为一个的类型是string，一个的类型是object
!==则与前面那个相反

JS的循环，条件判断

JS的条件判断和循环其实和Java是一致的
但是JS多了for-in和for-of循环
**for-in：**可以看作是foreach的变体
如下：for(var x in array){} 顺序遍历数组中的元素
for-of：和上面差不多，但是作用的对象是可以迭代的变量（数组，字符串）
如下：for(var x of iterable){} 如果是字符串，则会一个一个地遍历字符

类型转换

构造函数获取：变量.constructor
类型转换，直接调用想转化的类型的构造函数，把想转化的变量作为参数即可
比如：String(11)

转化成String还可以通过变量的toString()方法
把日期转化成Number会转化成这个日期的毫秒数

可以通过单目运算符 + 把字符串转化为数字
比如：document.write(typeof +"1");
结果为number

正则表达式

通过两个正斜杠包含起来的字段，后面跟着修饰符
比如：/hello/i
search方法和replace方法都涉及使用正则表达式搜索内容
修饰符

正则表达式书写
[0-9]：0-9之间的任何数字
[abc]：abc中的一位
元字符：

正则表达式是一个对象，有一些匹配字符串的方法

• test(str):搜索字符串内是否有匹配正则表达式的子串，如果有返回true
• exec(str)：同上，搜索，但是如果搜索到返回搜索到的匹配子串

<script>
            var str="I love JavaScript";
            var re=/love/;
            document.write(re.test(str)+"<br>");
            document.write(re.exec(str)+"<br>");
        </script>

错误处理

也和java类似，如下：

try{
                
            }catch(err){

            }finally{

            }

由于js是动态类型，所以catch的参数只有名字，没有类型error
也可以选择自己手抛错误，比如：throw “错误”
JS会尽可能地转化类型，所以可以把String类型转化成error类型

错误的类型

this关键字：

当在标签的属性中使用时，this指代的是标签对象
比如：<button type="button" onclick="this.style.display='none'"></button>
一般this指代的是包含这个的对象

箭头函数

类似Java的lamada，但是箭头是等于号组成的

(参数)=>{语句}

实际上就是函数的简化形式
当只有一个参数时，括号可以省略

var1=>{}

当只有一条语句时，代码块的括号也可以删除

func=()=>document.write("hello");

如果语句中只有一个值的话，那这个值就是返回值

func=()=>"hello";
            a=func();
            document.write(a);

类

声明方式和Java差不多，但是构造函数不一样

class example{
                constructor(){

                }
                method1(){

                }
                method2(){
                    
                }
            }
            var e=new example();

内部的方法也不需要function的前缀，只需要名字即可
创建对象直接用new即可

导入导出

从外部文件中导入一部分就是导入
比如：

<script type="import">
            import message from "/aa.js";
        </script>

message是文件内默认导出的名称
导出分为默认导出和命名导出，为文件展现给外部提供给外部导入
命名导出：
可以直接在变量前声明导出：export const a=1;
也可以在末尾声明导出的变量：export{变量名字...}; 可以导出多个
默认导出：

default export 变量名;

其他

• 设置断点

debugger;

• 延迟加载
  最好把js代码放在页面渲染的后面，因为在执行js阶段，渲染不会进行，所以最好先渲染再执行JS代码
  或者可以通过把script标签的defer属性设置为true来延迟加载
• 避免过多使用DOM（比如document.getElementById()）

对象

对象属性的操作：
对象属性的访问

obejct.property
obejct["property"]

对象内部包含属性，可以先创建对象（new Object()）再在外部创建属性

  <script>
            var v=new Object();
            v.property="11";
            document.write(v.property);
        </script>

删除属性：

delete ob.property	 

会同时删除对象的属性和值
通过for-in访问对象属性：

<script>
            var v=new Object();
            v.property="11";
            v.a="12";
            v.b="13";
            for(var x in v){
            document.write(v[x]);
            }
        </script>

for-in中var x储存的是属性的名称，所以需要v[x]访问属性值

对象转化成数组

var array=Object.values(对象);

JSON.stringify(对象)

可以把对象转化成字符串
比如：

<script>
            var v=new Object();
            v.property="11";
            v.a="12";
            v.b="13";
            
            document.write(JSON.stringify(v));
        </script>

输出是对象的json格式
{“property”:“11”,“a”:“12”,“b”:“13”}

可以转化Date对象之类的，看看内部的结构

转化数组也是转化成json格式的数组

JS对象的Getter和Setter方法

其实用普通的函数是可以解决getter和setter的方法，但是可能js提供的方法会更加清晰
getter：
get 函数名(){return xxx;}
setter
set 函数名(x){}

<script>
            var v ={
                x:1,
                set setX(x1){
                    this.x=x1;
                },
                get getX(){
                    return x;
                }
            }
        </script>

getter和setter方法可以像属性一样使用
比如：v.setX=1; document.write(v.getX);
不必加上括号当作正常的方法

外部对象的构造器

可以通过一个构造器，也就是模板，创建多个对象
有点像类，但是比类简洁
需要在外部声明：
function 对象原型名(构造参数){
…
}
通过new 对象原型名(构造参数即可创建)
比如：

function P(h){
                    this.x=h;
                }
                var p=new P(1);

可以创建多个对象，但是不能在外部创建属性，在构造方法内未声明的变量均可视为内部属性
但是可以通过prototype添加属性

<script>
            function P(h){
                    this.x=h;
                }
                var p=new P(1);
                P.prototype.func=function(){
                    document.write(1);
                }
                P.prototype.name="对象";
                document.write(p.name);
                document.write(p.func);
                document.write(JSON.stringify(p));
        </script>

但是外部定义的属性和函数并不能在对象中真正显示，只能通过引用得出

Set集合

<script>
            var set=new Set(["1","2","3"]);
            set.add("4");
            set.has("4");
            set.forEach((v)=>document.write(v+"<br>"));
            document.write(set.size+"<br>");
            set.delete("1");
            for(var v of set.values()){
                document.write(v+",");
            }
        </script>

初始化时，构造器的参数应该是一个数组的原始表达，或者干脆就是空

可以通过 object instanceof Set 验证对象是否为Set集合
values()和key（）返回的都是值的迭代器，可以通过for-of迭代
entries()返回的是[key,value]

Map映射

创建：

var map=new Map([["a",1],["b",2],["c",3]]);

参数是键值对的原型，外部一个[] ，内部一个[]作为节点，每个节点用逗号隔开

set:

map.set("a",2);
map.set("d",4);

可以作为添加，也可以作为修改，如果键存在就是修改，键不存在就是添加

get(键)/has(键)：

map.has("d")

通过键得到是否存在

forEach():
参数内的函数一定要是两个参数的（key，value）

map.forEach((key,value)=>document.write(key+":"+value+"<br>"));

函数：

函数可以作为一个变量：
var func=function(){document.write(“函数”)};
调用时可以把变量的名字当作函数的名字，后面的函数表达式是匿名的

函数实际上是个对象：
可以通过new创建：

var func2=new Function("a","b","return a*b");

前面的是参数，后面的是函数内的语句

调用和上面同理，但是最好不要这么定义函数
可以在函数内通过arguments.length 知道函数被调用时收到的参数个数(注意：JS不会检查实际输入的参数是否和形参数量相等，如果参数少于形参，则没有的形参会被赋值成undefined)
arguments也可以看作是参数的数组，可以通过下标访问
arguments[0];

函数可以自调用：

(匿名函数定义)();

(function(){document.write("hello")})();

函数的调用

每个函数都有一个对象包含，就算是外部函数也是由window对象包含，所以外部函数的this指代的是window对象，外部函数也可以由window对象调用

函数的调用也可以通过new调用
比如：

<script>
            function func(a){
                this.a=a;
            }
            var v=new func(1);
            document.write(v.a);
        </script>
   

这时候函数会被看作是构造函数，这会创建一个对象

call（）和apply（）

<script>
            var ob1={
                func:function(){
                    document.write(this.a*this.b);
                }
            };
            var ob2={
                a:1,
                b:2
            }
            ob1.func.call(ob2);
            ob1.func.apply(ob2);
        </script>

由于JS的对象没有单纯的继承，所以要想实现对象内函数的复用，可以借助于call和apply
这两个方法都是用于把一个对象中的函数借给另一个对象使用

对象1.函数名.call(对象2,需要传入的参数)；	
对象1.函数名.apply(对象2,需要传入的参数（以数组的原型形式）)；	

前提是函数内用到的对象1的属性对象2必须拥有，也就是二者具有相似性，而且函数内的调用需要带上this

bind()也是类似，但是不带后面的传入的参数

类

类中的全局变量并不会显示地声明，而是在构造器中隐式声明：

class exam{
                constructor(age){
                    this.age=age;
                }
            }

有个似乎没有声明的age变量，这就是类的全局属性，通过构造函数定义

类的继承和Java差不多，但是由于没有访问修饰符，所以功能方面差了一些，但是同样是继承属性方法，可以使用super

静态函数：
仅仅只能在类中使用，是独属于类的

class exam{
                constructor(age){
                    this.age=age;
                }
                static getAge(){
                    return this.age;
                }
            }
            document.write(exam.getAge());