精华内容
下载资源
问答
  • js代码-JS Class类练习

    2021-07-16 12:44:48
    js代码-JS Class类练习
  • js class类简介

    千次阅读 2019-12-05 14:55:43
    问题描述: 调用其中的方法、向其中添加方法 、定义变量、get和...//定义 class Test { constructor(x, y) { this.x = x; this.y = y; } myFun1() { // 方法1 return (this.x + this.y); } myFun2() {...

    问题描述:

    调用其中的方法、向其中添加方法 、定义变量、get和set

    问题分析:

    解决方案:

    //定义类
    class Test {
      constructor(x, y) {
        this.x = x;
        this.y = y;
      }
      myFun1() {
        // 方法1
        return (this.x + this.y);
      }
      myFun2() {
        // 方法2
      }
    }
    export {Test};

    1、调用其中的方法。

    import {Test} from './Test';
    let test = new Test('Hello', 'World');
    console.log(test.toString());

    2、添加方法。

    Test.prototype = {
       // 方法3
       myFun3(){}
    };

    3、定义变量不可以在外部定义,只能放在构造方法constructor中,这里的this指向实例对象。

    constructor(x, y) {
       this.x = x;
       this.y = y;
    }

    4、对其中某个属性可以使用get和set,从而进行进一步的存取操作。

    get prop() {
       return 'getter';
    }
    set prop(val) {
       console.log('setter:' + val);
    }
    let test = new Test();
    test.prop = 123;
    // setter: 123
    test.prop
    // 'getter'

     

    展开全文
  • JSClass类的详解

    千次阅读 多人点赞 2019-04-25 09:43:56
        在ES6中,class ()作为对象的模板被引入,可以通过 class 关键字定义。它可以被看作一个语法糖,让对象原型的写法更加清晰、更像面向对象编程的语法。     实际上是个“特殊的函数”,就像你能够...

    概述

        在ES6中,class (类)作为对象的模板被引入,可以通过 class 关键字定义类。它可以被看作一个语法糖,让对象原型的写法更加清晰、更像面向对象编程的语法。
        类实际上是个“特殊的函数”,就像你能够定义的函数表达式和函数声明一样,类语法有两个组成部分:类表达式和类声明。

    严格模式

        类和模块的内部,默认就是严格模式,所以不需要使用 use strict 指定运行模式

    类的声明

    定义一个类的一种方法是使用一个类声明,即用带有class关键字的类名(这里是“Rectangle”)
    函数名和实例化构造名相同且大写(非强制)

    class Person {
    	constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    

    函数声明和类声明之间的一个重要区别是函数声明会提升,类声明不会。需要先进行声明,再去访问,否则会报错

    var person= new Person()
    class Person {
    	constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    // Personis not defined
    

    类声明不可以重复

    class Person {}
    class Person {}
    // TypeError Identifier 'Person' has already been declared
    

    类必须使用 new 调用,否则会报错。这是它跟普通构造函数的一个主要区别,就是后者不用 new 也可以执行

    class Person {
    	constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    Person()
    // TypeError Class constructor Person cannot be invoked without 'new'
    

    类表达式(类定义)

    类表达式可以是被命名的或匿名的

    /* 匿名类 */ 
    let Person = class {
      constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    
    /* 命名的类 */ 
    let Person = class Person {
      constructor(x, y) {
        this.x = x
        this.y = y
      }
    }
    

    类的方法

    constructor 方法

        constructor 方法是类的默认方法,通过 new 命令生成对象实例时,自动调用该方法(默认返回实例对象 this)。一个类必须有 constructor 方法,如果没有显式定义,一个空的 constructor 方法会被默认添加。一个类只能拥有一个名为 “constructor” 的特殊方法,如果类包含多个 constructor 的方法,则将抛出 一个 SyntaxError 。

    class Person {
       constructor(x, y) {
        this.x = x    // 默认返回实例对象 this
        this.y = y
      }
      toString() {
        console.log(this.x + ', ' + this.y)
      }
    }
    

    注意:

    1. 在类中声明方法的时候,方法前不加 function 关键字
    2. 方法之间不要用逗号分隔,否则会报错
    3. 类的内部所有定义的方法,都是不可枚举的(non-enumerable)
    4. 一个类中只能拥有一个 constructor 方法

    静态方法

        静态方法可以通过类名调用,不能通过实例对象调用,否则会报错

    class Person {
        static sum(a, b) {
            console.log(a + b)
        }
    }
    var p = new Person()
    Person.sum(1, 2)  // 3
    p.sum(1,2)     //  TypeError p.sum is not a function
    

    原型方法

        类的所有方法都定义在类的 prototype 属性上面,在类的实例上面调用方法,其实就是调用原型上的方法
        原型方法可以通过实例对象调用,但不能通过类名调用,会报错

    class Person {
    	constructor() {
    		// 默认返回实例对象 this
    	}
        sum() {
        	
        }
        toString() {
        	console.log('123456')
      	}
    }
    // 给 Person 的原型添加方法
    Person.prototype.toVal = function() {
    	console.log('I am is toVal')
    }
    
    // 等同于
    Person.prototype = {
      constructor() {},
      sum() {},
      toString() {}
    }
    
    var p = new Person()
    p.toString()       // 123456
    p.toVal()          // I am is toVal
    Person.toString()  // TypeError Person.toStringis not a function
    Person.toVal()  // TypeError Person.toVal is not a function
    

    实例方法

        实例方法也可以通过实例对象调用,但同样不能通过类名调用,会报错

    class Person {
        constructor() {
            this.sum = function(a, b) {
                console.log(a + b)
            }
        }
    }
    var p = new Person()
    p.sum(1,2)       // 3
    Person.sum(1,2)  // TypeError Person.sum is not a function
    
    展开全文
  • JS es6的Class类详解

    万次阅读 多人点赞 2020-09-05 10:17:18
    文章目录JS es6的Class类详解class基本语法Class的基本语法之constructorClass的基本语法之类的调用方式Class的基本语法之getter和setterClass的基本语法之类的属性名Class的基本语法的特别注意点Class的静态属性和...

    JS es6的Class类详解

    class基本语法

    JavaScript 语言中,生成实例对象的传统方法是通过构造函数和原型的组合模式.ES6 提供了更接近传统语言(java)的写法,引入了 Class(类)这个概念,作为对象的模板。通过class关键字,可以定义类。

    class point{
    	constructor(x,y){
            this.x=x;
            this.y=y;
        }
        play(){
            console.log("我会玩");
        }
    }
    

    ES6 的class可以看作只是一个语法糖,它的绝大部分功能,ES5 都可以做到,新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。

    注:“语法糖”:是由英国计算机科学家彼得·约翰·兰达(Peter J. Landin)发明的一个术语,指计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。

    ES6 的class与ES5写法的几个核心注意点:
    ES5 的构造函数Point,对应 ES6 的Point类的构造方法。
    类的所有方法都定义在类的prototype属性上面。
    定义“类”的方法的时候,前面不需要加上function这个关键字,直接把函数定义放进去了就可以了
    方法之间不需要逗号分隔,加了会报错
    ES6的class使用方法与ES5的构造函数一模一样

    //类的所有方法都定义在类的prototype属性上面。
    class piont{
        constructor(){
    		//
        }
        play(){
            
        }
    }
    //上述代码等价于
    point.prototype={
        constructor() {},
        play(){};
    }
    
    //在类的实例上面调用方法,其实就是调用原型上的方法。
    class Ba{
    	//
    }
    let b=new Ba();
    b.constructor===Ba.prototype.constructor//true
    

    另外:ES5 的构造函数Point,对应 ES6 的Point类的构造方法。

    由于类的方法都定义在prototype对象上面,所以类的新方法可以添加在prototype对象上面。Object.assign方法可以很方便地一次向类添加多个方法。

    class ponit{
        constructor(){
            
        }
    }
    Object.assign(Point.prototype,{
    	play(){};
    })
    //Class直接定义的方法之间不需要逗号分隔,加了会报错. 但是这里是Object.assign的方法格式, 这里面需要往Point.prototype里面添加的方法就需要符合对象的默认格式
    

    类的内部所有定义的方法,都是不可枚举的(non-enumerable)。通过Object.assign方法往类的原型上添加的方法,constructor不可枚举, 其他的可以枚举

    Class的基本语法之constructor

    constructor方法是类的默认方法,通过new命令生成对象实例时,自动调用该方法。一个类必须有constructor方法,如果没有显式定义,一个空的constructor方法会被默认添加。

    constructor方法默认返回实例对象(即this),完全可以指定返回另外一个对象
    (得是在创造class时就定义设置的, 在创造完class后,通过Object.assign的方式是没法改变构造函数的返回值的).

    Class的基本语法之类的调用方式

    类必须使用new调用,否则会报错。这是它跟普通构造函数 ( 普通构造函数完全可以当做普通函数使用 ) 的一个主要区别,后者不用new也可以执行。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9USZMu4q-1599271907892)(C:\Users\dell\Desktop\凯文的前端博客\images2\class1.png)]

    Class的基本语法之getter和setter

    与 ES5 一样,在“类”的内部可以使用get和set关键字,对某个属性设置存值函数和取值函数,拦截该属性的存取行为。

      class demo{
                constructor(age){
                    this.age=agie;
                    this._age=age;
                }
                get age(){
                    return this._age;
                }
                set age(value){
                    this._age=value;
                    console.log("年龄"+value);
                }
            }
            let kevin=new demo(9);
            kevin.age=18;
            console.log(kevin.age);
    
    Class的基本语法之类的属性名

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1iEAo4qQ-1599271907895)(C:\Users\dell\Desktop\凯文的前端博客\images2\class2.png)]

    上面代码中,Square类的方法名getArea,是从表达式得到的。

    Class的基本语法的特别注意点

    (1)严格模式

    类和模块的内部,默认就是严格模式,所以不需要使用use strict指定运行模式。只要你的代码写在类或模块之中,就只有严格模式可用。考虑到未来所有的代码,其实都是运行在模块之中,所以 ES6 实际上把整个语言升级到了严格模式。

    (2)不存在提升

    new foo();

    class foo{};

    上面代码中,Foo类使用在前,定义在后,这样会报错,因为 ES6 不会把类的声明提升到代码头部。

    (3)name 属性

    class point{

    }

    point.name//point

    由于本质上,ES6 的类只是 ES5 的构造函数的一层包装,所以函数的许多特性都被Class继承,包括name属性。

    (4)this 的指向

    类的方法内部如果含有this,它默认指向类的实例。但是,必须非常小心,一旦单独使用该方法,很可能报错。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yWvVyll7-1599271907897)(C:\Users\dell\Desktop\凯文的前端博客\images2\class3.png)]

    printName方法中的this,默认指向Logger类的实例。但是,如果将这个方法提取出来单独使用,this会指向该方法运行时所在的环境(由于 class 内部是严格模式,所以 this 实际指向的是undefined),从而导致找不到print方法而报错。

    解决办法:

    一个比较简单的解决方法是,在构造方法中绑定this,这样就不会找不到print方法了。

    另一种解决方法是使用箭头函数。箭头函数位于构造函数内部,它的定义生效的时候,是在构造函数执行的时候。这时,箭头函数所在的运行环境,肯定是实例对象,所以this会总是指向实例对象。

    class Logger{
        constructor(){
            this.printName=this.printName.bind(this);
            //但是请注意bind之后返回的函数里面的this就永久锁死了问题:!!! !!! 坚决别用 
        }
    }
    //箭头函数
    class Obj{
        constructor(){
            this.getThis=()=>this;
        }
    }
    let o=new Obj();
    o.getThis()===o//true
    

    Class的静态属性和方法

    类相当于实例的原型,所有在类中定义的方法,都会被实例继承。如果在一个方法前,加上static关键字,就表示该方法不会被实例继承,而是直接通过类来调用,这就称为“静态方法”。

     class Person{
                static sum=0;
                constructor(){
                    this.add();
                }
                add(){
                    Person.sum++;
                }
            }
            let kaiwen=new Person();
            console.log("当前的聊天室人数为:"+Person.sum);
            //作用:当没有实例化的时候,我们可以通过静态的属性和方法去获取一些信息
     // 注意,如果静态方法包含this关键字,这个this指的是类,而不是实例。静态方法可以与非静态方法重名。
    

    父类的静态方法,可以被子类继承静态方法也是可以从super对象上调用的。

     class Person{
                constructor(name){
                    this.name=name;
                    this.sex="男";
                }
            }
            class Student extends Person{
                constructor(name,age){
                    super(name);
                    this.age=age;
                }
            }
            let s=new Student("张三",11);
            console.log(s.name);
            console.log(s.age);
            console.log(s.sex);
    

    Class的私有方法和私有属性

    私有方法和私有属性:是只能在类的内部访问的方法和属性,外部不能访问。
    这是常见需求,有利于代码的封装,但 ES6 不提供,只能通过变通方法模拟实现。

    _bar方法前面的下划线,表示这是一个只限于内部使用的私有方法。但是,这种命名是不保险的,在类的外部,还是可以调用到这个方法

    下面代码中的写法不仅可以写私有属性,还可以用来写私有方法

     class Cat{
                #eyes="眼睛";
                static pai(){
                    console.log("凯文");
                }
                say(){
                    Cat.pai();
                    console.log("猫有一双大大的"+this.#eyes);
                }
            }
            let kate=new Cat();
            kate.say();
    

    私有属性也可以设置 getter 和 setter 方法。

    私有属性不限于从this引用,只要是在类的内部,实例也可以引用私有属性。

    构造函数的新属性

    ES6 为new命令引入了一个new.target属性,该属性一般用在构造函数之中,返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的,new.target会返回undefined,因此这个属性可以用来确定构造函数是怎么调用的。

    私有属性也可以设置 getter 和 setter 方法。

    私有属性不限于从this引用,只要是在类的内部,实例也可以引用私有属性。

    构造函数的新属性

    ES6 为new命令引入了一个new.target属性,该属性一般用在构造函数之中,返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的,new.target会返回undefined,因此这个属性可以用来确定构造函数是怎么调用的。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rSe8aqiI-1599271907900)(C:\Users\dell\Desktop\凯文的前端博客\images2\class4.png)]

    展开全文
  • JSClass类的继承

    千次阅读 多人点赞 2019-04-25 14:26:29
    Class继承     Class 可以通过 extends 关键字实现继承,这比 ES5 的通过修改原型链实现继承,要清晰和方便很多 class Animate { constructor() { // 默认返回实例对象 this } } class Dog extends ...

    Class继承

        Class 可以通过 extends 关键字实现继承,这比 ES5 的通过修改原型链实现继承,要清晰和方便很多

    class Animate {
    	constructor() {
        	// 默认返回实例对象 this
        }
    }
    class Dog extends Animate {
    	constructor() {
    		super()
        }
    }
    

        子类必须在 constructor 方法中调用super方法,否则新建实例时会报错,子类就得不到 this 对象。这是因为子类自己的 this 对象,必须先通过父类的构造函数完成塑造,得到与父类同样的实例属性和方法,然后再对其进行加工。如果不调用 super 方法,子类就得不到this对象。
        ES5 的继承,实质是先创造子类的实例对象 this,然后再将父类的方法添加到 this 上面(Parent.apply(this))。ES6 的继承机制完全不同,实质是先将父类实例对象的属性和方法,加到 this上面(所以必须先调用super方法),然后再用子类的构造函数修改 this。

    1. this 关键字的使用

        在子类的构造函数中,只有调用 super 之后,才可以使用 this 关键字,否则会报错。这是因为子类实例的构建,基于父类实例,只有 super 方法才能调用父类实例。

    class Animate {
    	constructor(x, y) {
        	// 默认返回实例对象 this
        }
    }
    class Dog extends Animate {
    	constructor(x, y, z) {
    		this.z = z    //  ReferenceError
    		super(x, y)   //  this 只能在super() 方法调用之后再使用
    		this.z = z 
        }
    }
    

    2. 父类的静态方法会被子类继承

        通过子类的类名去调用继承的父类静态方法

    class Animate {
    	constructor() {
    	    // 默认返回实例对象 this
    	}
    	static show() {
    	    console.log('我是show方法')
    	}
    }
    
    class Dog extends Animate {
    	constructor() {
    		super()
    	}
    }
    var dog = new Dog()
    Dog.show()     //  我是show方法
    

    3. 子类中重写父类的方法
        如果在子类中也写入 num 方法,和父类中的方法重名,这样就会覆盖父类的 num 方法

    class Animate {
    	constructor() {
    	    // 默认返回实例对象 this
    	}
    	num() {
    	    console.log('我是父类的num方法')
    	}
    }
    
    class Dog extends Animate {
        constructor() {
            super()
        }
        num() {
            console.log('我是子类的num方法')
        }
    }
    var dog = new Dog()
    dog.num()     //  我是子类的num方法
    

        如果不想覆盖而是想引用父类的 num 方法,那么就在子类的 num 方法中通过 super 来调用父类的 num 方法,super.num()

    class Dog extends Animate {
        constructor() {
            super()
        }
        num() {
        	super.num()  //  调用父类的 num() 方法
            console.log('我是子类的num方法')
        }
    }
    var dog = new Dog()
    dog.num()     
    
    //  我是父类的num方法
    //  我是子类的num方法
    

    4. Object.getPrototypeOf()

        Object.getPrototypeOf方法可以用来从子类上获取父类。因此,可以使用这个方法判断,一个类是否继承了另一个类

    Object.getPrototypeOf(Dog) === Animate   // true
    

    super 关键字

        super这个关键字,既可以当作函数使用,也可以当作对象使用

    1. super作为函数使用

        super 作为函数调用时,代表父类的构造函数。ES6 要求,子类的构造函数必须执行一次super函数。并且,super() 只能用在子类的构造函数之中。

    class Animate {}
    class Dog extends Animate {
    	constructor() {
    		super()
    	}
    }
    

        注意: super 虽然代表了父类 Animate 的构造函数,但是返回的是子类 Dog 的实例,即 super 内部的 this 指的是子类 Dog 的实例,因此 super() 在这里相当于Animate.prototype.constructor.call (this)

    2. super作为对象使用

        super作为对象时,在普通方法中,指向父类的原型对象;在静态方法中,指向父类。

    class Animate {
    	constructor() {
    		this.x = 2
    		this.fn = function() {
    			console.log('我是父类实例的方法')
    		}
    	}
    	num() {
    		console.log('我是父类的num方法')
    	}
    }
    class Dog extends Animate {
    	constructor() {
    		super()
    	}
    	toString() {
        	super.num()   //  调用父类的 num() 方法
        	console.log(super.x)  
            console.log(super.fn) 
            console.log(this.x)
            this.fn()  
    	}
    }
    var dog = new Dog()
    dog.toString()
    
    //  我是父类的num方法   
    //  undefined
    //  undefined
    //  2
    //  我是父类实例的方法
    

        子类 Dog 当中的 super.num(),就是将 super 当作一个对象使用。这时,super 在普通方法之中,指向Animate.prototype,所以 super.num() 就相当于 Animate.prototype.num()

        注意: 由于super指向父类的原型对象,所以定义在父类 Animate 实例上的方法或属性,是无法通过 super 调用的。

    展开全文
  • JS classList 用法简介

    千次阅读 2017-11-14 17:38:40
    JS classList 用法简介定义及用法 classList 属性返回元素类名. 该属性用于在元素中添加, 移除及切换 CSS .
  • js中es6 class类的继承

    千次阅读 2019-09-19 18:02:55
    js中 es6 class类的继承 语法 // 父类 class Father{ } // 子类继承父类 class Son extends Father { } 子类使用super关键字访问父类的方法 //定义了父类 class Father { constructor(x, y) { this.x = x; ...
  • JSClass - 创建

    千次阅读 2019-06-29 19:11:54
    Class类实现了在JavaScript中声明一个新的类, 并通过构造函数实例化这个类的机制。通过使用Class.create()方法, 你实际上声明了一个新的类, 并定义了一个initialize()方法作为构造函数, 一旦你在这个声明的类的...
  • JS进阶之面向对象ES6-class类

    千次阅读 2020-11-05 19:54:05
    JS进阶之面向对象ES6-class类,面向对象OOP
  • js 添加删除替换class

    万次阅读 2016-07-27 16:26:47
    //删除 //添加 //替换
  • 扩展.js 扩展机制。 文档 () 如何使用 浏览器 < script src = "lib/ClassExtend.js" > < script > function ClassFoo() { } function ClassBar(arg) { ClassFoo . call ( this , arg ) ; } ...
  • js获取class类封装方法

    千次阅读 2014-09-28 23:22:16
    function checkclass (startclass,endclass) {//判断类名 var arr=startclass.split(" ");//多个类名用空格分隔成不同元素的数组; for (var i=0; i; i++) { if(arr[i]==endclass){//1.2.被分割的数组元素里面...
  • JS 中的class类的基本使用 1. 基本使用 class的基本语法 使用class关键字定义一个类,本质上是一个function,可以看做一个语法糖,定义了同一组对象(又称为实例)共有的属性和方法 class Person { constructor(x...
  • js中关于class类的关键字的使用

    千次阅读 2019-12-18 20:21:58
    js中关于class类的关键字的使用 1、什么是类? 这里我们可以理解类是一个具有相同属性和行为的群体的集合。在es6中,首次引入了类的概念,通过创建class关键字来定义一个类的模板。 2、在js中实现创建一个Class...
  • js-ES6类Class创建与使用

    千次阅读 2018-12-18 17:44:47
    1.ES6提供了更接近传统语言的写法,引入了Class)这个概念,作为对象的模板。通过class关键字,可以定义。 2.//定义 class Point { constructor(x, y) { this.x = x; this.y = y; } toString() { ...
  • js 封装自己的class类

    千次阅读 2016-11-21 11:50:27
    <div class="demo"> <div></div> <div></div> <div class="demo"> <div></div> <div></div> <div class="demo"> <div></div> <div class="demo"> //因为IE6,IE7浏览器不支持ClassName...
  • JS原生态class类选择器

    千次阅读 2017-04-24 14:28:26
    function getElementsByClass(classnames){ var classobj = new Array(); var classint = 0; var tags =document.getElementsByTagName("*"); for(var i in tags){ if(tags[i].nodeType == 1){ if(ta
  • js-封装自己的class类

    千次阅读 2016-11-23 19:56:32
    封装自己的class类,对于高版本浏览器,支持document.getElementsByClassName,对于IE678,不支持的情况要进行处理。首先判断是否支持,不支持再进行如下处理。 <!DOCTYPE html> <title>Document <style
  • JS Class 使用以及静态方法的调用

    千次阅读 2020-10-21 10:15:55
    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>... //
  • MSClass (Class Of Marquee Scroll通用不间断滚动JS封装)多个类别 滚动 JS 图片滚动 文字滚动
  • PyClass - 在 JS 中编写 Python JS编写Python风格的,兼容Nodejs和浏览器。 没有var me/self/_i/SELF/that/_this_/_that_ = this在你的 JS 中了...... 安装 npm install pyclass bower install pyclass ...
  • <!... , initial-scale=1.0"> <title></title> ... <div id='box' class="a b c">...通过getAttribute('class')即可获取,或者是获取dom节点的className属性 运行上面的代码就会看到控制台输出对应的类名 a b c
  • jsclass的使用

    千次阅读 2021-01-12 23:36:26
    ES6中的使用 如何创建一个 class User{} //第一种 let User=class{} //第二种 构造函数的使用与参数初始化 class User{ constructor(name){ this.name=name; } } 静态属性的定义与使用 class request{ ...
  • js 改变背景(backgroundImage)和 名称(class)
  • ES6之JS

    万次阅读 2019-12-18 23:39:04
    声明以 class 关键字开始,其后是的名称;剩余部分的语法看起来就像对象字面量中的 方法简写,并且在方法之间不需要使用逗号。 class PersonClass { // 等价于 PersonType 构造器 constructor(name) { this....
  • private-class保护私有属性的一个模块
  • 流星类js 流星的 classjs

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 355,410
精华内容 142,164
关键字:

jsclass类