JavaScript入门资料

最新推荐文章于 2023-01-12 16:01:41 发布
最新推荐文章于 2023-01-12 16:01:41 发布
阅读量609 收藏 2
点赞数
分类专栏： javaScript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/samuelandkevin/article/details/72911200
版权

基础

  • JavaScript中的全局函数-数值型函数
  • JavaScript中的全局函数
  • JavaScript中的特殊形式函数-匿名函数的应用
  • JavaScript中的对象-如何自定义对象
  • JavaScript中的对象-对象的结构
  • JavaScript中的对象-属性的特性
  • JavaScript中的对象-属性特性描述
  • JavaScript中的对象-对象的特性
  • JavaScript中的内建对象-Date对象
  • JavaScript中的内建对象-RegExp对象
  • JavaScript中的内建对象-Error对象
  • JavaScript中的数组对象
  • JavaScript中的事件简介
  • DOM2级事件绑定和移除
  • JavaScript中的事件对象及兼容性
  • JavaScript中的兼容性问题和onload事件
  • JavaScript表单验证

进阶

JavaScript中的特殊形式函数

<eg1>
    function a(param){
        function b(param1){
            return param1 + 10;
        }
        return '在a函数体内调用b函数结果' + b(param);
    }
    document.write(a(5));


//输出结果：
//在a函数体内调用b函数结果15
<eg2>
    function a(param){
        var b = function(param1){
            return param1 + 10;
        }
        return '在a函数体内调用b的结果:' + b(param);
    }
    document.write(a(5));


//输出结果：
//在a函数体内调用b的结果:15
<eg3>
//返回函数的函数
    function a(){
        alert('aaa');
        return function(){
            alert('bbb');
        };
    }
//调用方式一:
    var b = a();
    b();

//调用方式二：
    a()();


//输出结果：
//弹框显示aaa,再弹框显示bbb
<eg4>
//重写自己的函数
    function a(){
        alert('aaa');
        a = function(){
            alert('bbb');
        }
    }

    a();
    a();


//输出结果：
//第一次调用，显示alert('aaa').第二次或之后调用，显示  alert('bbb')

<eg5>
//函数的自调用
    var a = function(){
        function setUp(){
            var setup = 'doSomeThing';
        }
        function doWhat(){
            alert('要执行的操作');
        }
        setUp();
        return doWhat();
    }();
    a();


//输出的结果是：
//弹框：'要执行的操作'

//分析：
//var a = function(){}() ; 这种格式为自调用
<eg6>
//创建函数方式一
    var func = new Function('a','b','return a+b');
    alert(func(3,4));   //弹框显示7
//创建函数方式二
    var func2 = function(a,b){return a+b}; //弹框显示7
    alert(func2(3,4));


//输出结果：
//弹框显示7
//分析：创建函数方式一和方式二是等价的。方式一是通过JS内置函数构造器创建的

JavaScript中的闭包

闭包理解：
突破自身函数作用域的限制，把函数内的局部变量共享到外部。
闭包缺点：
1.闭包会使到函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄漏。尽量在退出函数之前，将不使用的局部变量全部删除。
2.闭包会在父函数外部，改变父函数内部变量的值。所以，如果你把父函数当做对象使用，把闭包当做它的公用使用方法，把内部变量当做它的私有属性，这时一定要小心，不要随便改变父函数内部变量的值。

//突破闭包自身作用域限制，从而达到全局共享
    function closure() {
        var a = 'return closure';
        return function(){
            return a;
        }
    }
    alert(closure()());


//输出结果：
//弹框显示'return closure'
//分析
//现想要 a = 'return closure' 全局共享。但 a 只是closure()函数的局部变量，通过closure() 返回 变量就可以达到目的。这种方法叫闭包
    function closure(param){
        var n = function(){
            return param;
        }
        param++;
        return n;

    }
    alert(closure(5)());


//输出结果：
//弹框显示6.

JavaScript中的闭包应用

    function f1(){
        var n = 1;
        test = function(){
            n+=1;
        }
        function f2(){
            alert(n);
        }
        return f2;
    }
    var res = f1();
    alert(res());


//输出结果：
//先弹框显示1，再弹框显示undefined
    var setVaule,getValue;
    (function(){
        var n = 0;
        setVaule = function(x){
            n = x;
        }
        getValue = function(){
            return n;
        }
    })()

    alert(getValue());
    setVaule(5);
    alert(getValue());


//输出结果：
//先弹框显示0，再弹框显示5.
    function test(x){
        var i = 0;
        return function(){
            return x[i++];
        }
    }
    var next = test(['a','b','c','d'])
    alert(next());
    alert(next());
    alert(next());
    alert(next());


//输出结果：
//先弹框显示a，再弹框显示b,再弹框显示c,再弹框显示d
    function f(){
        var a=[];
        var i;
        for(i=0;i<3;i++){
            a[i] = function(){
                return i;   
            }
        }
        return a;   
    }
    var test = f();
    alert(test[0]());
    alert(test[0]());
    alert(test[0]());


//输出结果：
//先弹框显示3，再弹框显示3,再弹框显示3
    function f(){
        var a=[];
        var i;
        for(i=0;i<3;i++){
            a[i] = (function(x){
                    return function(){
                        return x;
                    }
                    })(i);//函数自调用
        }
        return a;           
    }

    var test = f();
    alert(test[0]());
    alert(test[1]());
    alert(test[2]());

//输出结果：
//先弹框显示0，再弹框显示1,再弹框显示2
    function f(){
        function test(x){
            return function(){
                return x;
            }
        }
        var a = [];
        var i;
        for (i=0;i<3;i++) {
            a[i] = test(i);
        }
        return a;       
    }
    var test = f();
    alert(test[0]());
    alert(test[1]());
    alert(test[2]());

//输出结果：
//先弹框显示0，再弹框显示1,再弹框显示2

JavaScript中的对象-对象的扩展性

//是否可以往该对象添加新的属性
(1)所有内置对象和自定义对象都是显示可扩展的，宿主对象的可扩展性有JavaScript引擎定义的。
(2)可以通过Object.preventExtensions()将对象设置为不可扩展的，而且不能再转换成可扩展的了，可以通过Object.isExtensible()检测对象是否可扩展的。
(3)preventExtensions()只影响到对象本身的可扩展性，如果给一个不可扩展的对象的原型添加属性，这个不可扩展的对象同样会继承这些新的属性
(4)可扩展性的目的是将对象锁定，防止外界干扰，通常和对象的属性的可配置行与可写性配合使用
(5)Object.seal()和Object.preventExtensions()类似，除了能够将对象设置为不可扩展的，还可以将对象的所有自身属性都设置为不可配置的。也就是说不能给这个对象添加新的属性，而且它已有的属性也不能删除或配置，不过他已有的可写属性依然可以设置。可以通过Object.isSealed()检测对象是否封闭
(6)Object.freeze()将更严格地锁定对象-冻结（frozen）.除了对象设置为不可扩展的和将其属性设置为不可配置的之外，还可以将它自身的所有数据属性设置为只读（如果对象的存储属性具有setter方法，存取器属性将不受影响，仍然可以通过给属性赋值调用他们）。可以使用Object.isFroze()来检测对象是否冻结

        var obj = {};
        //检测对象是否可扩展
        console.log(Object.isExtensible(obj));  //true
        var d = new Date();
        console.log(Object.isExtensible(d));    //true
        obj.x = 10;
        console.log(obj.x);                     //10

        //通过preventExtension() 将对象变为不可扩展的
        obj1 = Object.preventExtensions(obj);
        console.log(obj1===obj);                //true
        console.log(Object.isExtensible(obj1)); //false
        console.log(Object.isExtensible(obj));  //false

        //为一个不可扩展的对象添加属性
        obj1.y = 20;                            
        console.log(obj1.y);                 //undefined
        Object.defineProperty(obj1,'z',{value:1});//为对象定义一个属性。报错：Uncaught TypeError: Cannot define property z, object is not extensible
        var obj = {
            x:10,
            y:20,
            name:'samuelandkevin'
        };
        obj.age = 22;//添加新属性age
        delete obj.x;//删除已有的属性x

        var objSeal = Object.seal(obj); //封闭对象
        console.log(objSeal===obj);     //true
        console.log(Object.isExtensible(objSeal));//false , 封闭对象不可扩展
        objSeal.y = 55;                 //封闭对象试图修改已有属性y的值
        console.log(objSeal.y);         //55. 封闭对象可以修改已有属性
        Object.defineProperty(obj,'name',{ //封闭对象试图将已有属性name修改它的获取方法
            get: function(){
                    return 'this is a test';
            }
        });                             //报错：Uncaught TypeError: Cannot redefine property: name at Function.defineProperty (<anonymous>)
        objSeal.z = 77;                 //封闭对象试图添加属性z
        console.log(objSeal.z);         //undefined,系统没有报错。
        delete objSeal.name;                //试图删除封闭对象的已有属性
        console.log(objSeal.name);      //samuelandkevin,证明不可以删除封闭对象的已有属性
        console.log(Object.isSealed(objSeal));//true ,Object.isSealed()判断对象是否被封闭
        Object.defineProperty(objSeal,'name',{value:'newName'});
        console.log(objSeal.name);      //newName

        //打印obj对象的'name'属性 。注意configurable为false 
console.log(Object.getOwnPropertyDescriptor(obj,'name'));//Object {value: "newName", writable: true, enumerable: true, configurable: false}
        var obj = {
            prop:function(){},
            foo:'samuelandkevin'
        };//定义一个对象，prop为方法，foo为属性
        obj.test = 'this is a test';
        delete obj.prop;
        var objFreeze = Object.freeze(obj);//冻结对象
        console.log(objFreeze===obj);      //true
        console.log(Object.isFrozen(objFreeze)); //true,(对象是否被冻结)
        objFreeze.x = 1;                        //试图往已冻结对象中添加属性
        console.log(objFreeze.x);           //undefined
        console.log(objFreeze.foo);         //samuelandkevin
        objFreeze.foo = 'newValue';         //试图修改已冻结对象里的属性
        console.log(objFreeze.foo);         //samuelandkevin,(修改失败，因为对象已冻结)


        //浅冻结
        var obj2 = {
            internal:{}//internal为一个对象
        };
        Object.freeze(obj2);//冻结
        obj2.internal.x = 1;
        console.log(obj2.internal.x); //1,(修改成功，因为对象是浅冻结)

        //深冻结
        function deepFreeze(obj){
            var prop,propkey;
            Object.freeze(obj);
            for(propkey in obj){
                prop = obj[propkey];
                if(!obj.hasOwnProperty(propkey)||!(typeof prop === 'object')||Object.isFrozen(prop)){
                    continue;
                }
                deepFreeze(prop);
            }
        }
        var obj3=  {
            internal:{}//internal为一个对象
        };
        deepFreeze(obj3);//冻结
        obj3.internal.x = 1;
        console.log(obj3.internal.x); //undefined,(修改失败，因为对象是深冻结)
            //默认对象是可扩展的，也就是非冻结的
            console.log(Object.isFrozen());      //false,非冻结

            //一个不可扩展的对象同时也是一个冻结的对象
            var obj = Object.preventExtensions({}); //不可扩展的对象obj
            console.log(Object.isFrozen(obj));     //true

            //一个非空对象默认是非冻结的
            var obj1 = {x:1};
            console.log(Object.isFrozen(obj1));    //false,非冻结
            Object.preventExtensions(obj1);
            console.log(Object.isFrozen(obj1));    //false,非冻结
            delete obj1.x;
            console.log(Object.isFrozen(obj1));    //true (没有任何元素的对象，空对象是冻结了)

            //一个不可扩展的对象，拥有一个不可写但可配置的属性，仍然是非冻结的
            var obj2={x:1};
            Object.preventExtensions(obj2);                     //不可扩展
            Object.defineProperty(obj2,'x',{writable:false});   //不可写
            console.log(Object.isFrozen(obj2));                 //fasle
            Object.defineProperty(obj2,'x',{configurable:false});//不可配置
            console.log(Object.isFrozen(obj2));                  //true. 冻结了

            //如果一个不可扩展的对象，拥有一个不可配置但可写的属性，是非冻结的
            var obj3 = {x:1};
            Object.preventExtensions(obj3);                       //不可扩展
            Object.defineProperty(obj3,'x',{configurable:false}); //不可配置
            console.log(Object.isFrozen(obj3));                   //false,非冻结的
            Object.defineProperty(obj3,'x',{writable:false});     //不可写
            console.log(Object.isFrozen(obj3));                   //true,冻结的

            //如果一个不可扩展的对象拥有一个访问器属性，它也是非冻结的
            var obj4 = {
                get test(){
                    return 1;
                }//拥有一个访问器属性
            }
            Object.preventExtensions(obj4);                     //不可扩展
            console.log(Object.isFrozen(obj4));                 //false，非冻结
            Object.defineProperty(obj4,'test',{configurable:false});//不可配置
            console.log(Object.isFrozen(obj4));                 //true，冻结

            var obj5 = {x:1};
            Object.freeze(obj5);
            console.log(Object.isFrozen(obj5));                 //true,冻结
            console.log(Object.isSealed(obj5));                 //true,封闭
            console.log(Object.isExtensible(obj5));             //false,不可扩展

JavaScript中的内建对象值Object对象

内建对象 ->数据封装对象:
(1)Object对象
定义:Object是Javascript中所有对象的父级对象，我们创建的所有对象都继承于此，包括内建对象
语法: new Object([value])
{name:value,name:value…}
描述:Object构造函数为给定的值创建一个对象包装。如果给定值是null or undefined,将会创建并返回一个
当以非构造函数形式被调用时，Object等同于new Object().
属性： Object.prototype: 可以为所有Object类型的对象添加属性。
(2)Object.prototype
(3)Number对象
(4)Boolean对象
(5)String对象
(6)Array对象
(7)Function对象

        //Object.keys使用 
        var arr = ['a','b','c'];
        console.log(Object.keys(arr));    //["0", "1", "2"]
        var obj ={
            0:'d',
            1:'e',
            2:'f'
        };
        console.log(Object.keys(obj));   // ["0", "1", "2"]

        var obj1 = Object.create({},{
            getFoo:{
                value:function(){
                    return this.foo;
                }   
            }
        });//creat 新建一个对象
        obj1.foo = 123;
        console.log(Object.keys(obj1));  //["foo"]

        //如果想获取一个对象的所有属性，包括不可枚举的，Object.getOwnPropertyNames();
        console.log(Object.getOwnPropertyNames(arr)); //["0", "1", "2", "length"]
        console.log(Object.getOwnPropertyNames(obj)); //["0", "1", "2"]
        console.log(Object.getOwnPropertyNames(obj1));//["getFoo", "foo"]
            //Object.getOwnPropertyDescriptor使用
            var obj = {get foo(){return 123;}};
               console.log(Object.getOwnPropertyDescriptor(obj,'foo'));//Object {set: undefined, enumerable: true, configurable: true, get: function}
            obj = {
                name:'samuelandkevin',
                age:22
            };
            console.log(Object.getOwnPropertyDescriptor(obj,'name'));//Object{value: "samuelandkevin", writable: true, enumerable: true, configurable: true}
            obj = {};//创建一个空对象
            Object.defineProperty(obj,'test',{
                value:'this is a test',
                writable:false,
                enumerable:false,
                configurable:true
            });
            console.log(Object.getOwnPropertyDescriptor(obj,'test'));//Object {value: "this is a test", writable: false, enumerable: false, configurable: true}

            var obj1 = {x:1};
            var obj2 = Object.create(obj1);
            console.log(Object.getOwnPropertyDescriptor(obj2,'x')); //undefined .自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性
            console.log(Object.getPrototypeOf(obj2));   //Object {x: 1} , obj2的原型是obj1
            console.log(Object.getPrototypeOf(obj2)===obj1); //true

            //Object.prototype.constructor:返回一个指向创建了该对象原型的函数引用
            var obj3 =new Object;
            console.log(obj3.constructor===Object); //true 
            var arr = new Array;
            console.log(arr.constructor === Array); //true

            function Test(){

            }
            var f = new Test();
            console.log(f.constructor); //function Test(){}
            console.log(f.toString());  //[object Object]
            Test.prototype.toString = function(){
                return '这是自定义的toString';
            }
            console.log(f.toString());  //这是自定义的toString
            var toString = Object.prototype.toString;
            console.log(toString.call(new Date));     //[object Date]
            console.log(toString.call(new String));   //[object String]
            console.log(toString.call(Math));         //[object Math]
            console.log(toString.call(undefined));    //[object Undefined]
            console.log(toString.call(null));         //[object Null]

            //Object.prototype.isPrototypeOf():检测一个对象是否存在另外一个对象的原型链上
            //Object.prototype.propertyIsEnumerable():检测指定的属性名是否是当前对象可枚举的自身属性
            //Object.prototype.toString():返回一个代表该对象的字符串
            //Object.prototype.valueOf():返回的是this值，即对象本身

JavaScript中的Number对象和Boolean对象

            var n = Number('123.123');       //不利用构造器构造
            console.log(n);          //123.123
            console.log(typeof n);   //number

            var n2 = new Number('123.123');  //利用构造器构造
            console.log(n2);          //Number {[[PrimitiveValue]]: 123.123}
            console.log(typeof n2);   //object

            console.log(Number.NEGATIVE_INFINITY);
            console.log(Number.POSITIVE_INFINITY);
            console.log(Number.MAX_VALUE);
            console.log(Number.MIN_VALUE);
            console.log(Number.NaN);
            console.log(Number.isNaN(NaN));       //true
            console.log(Number.isNaN(0/0));       //true
            console.log(Number.isNaN(Number.NaN));//true
            console.log(Number.isNaN(''));        //false
            console.log(Number.isNaN(true));      //false
            console.log(Number.isNaN('hello'));   //false
            console.log(Number.isNaN(undefined)); //false
            console.log(Number.isNaN(' '));       //false

            var n3 = 12345.6789
            console.log(n3.toFixed()); //12346
            console.log(n3.toFixed(1));//12345.7
            console.log(n3.toFixed(2));//12345.68
            console.log(2.45.toFixed(1));//2.5
            console.log(1.23e-20.toFixed(2));//0.00

            var n4 = 77.12563
            console.log(n4.toExponential());//7.712563e+1
            console.log(n4.toExponential(1));//7.7e+1
            console.log(n4.toExponential(2));//7.71e+1
            console.log(n4.toExponential(3));//7.713e+1

            var n5 = 5.123456
            console.log(n5.toPrecision());//5.123456
            console.log(n5.toPrecision(1));//5
            console.log(n5.toPrecision(2));//5.1
            console.log(n5.toPrecision(3));//5.12

            var n6 = new Number(255);
            console.log(n6.toString());//255
            console.log(n6.toString(8));//377
            console.log(n6.toString(10));//255
            console.log(n6.toString(16));//ff
            console.log(n6.toString(2));//11111111
            //测试布尔值对象
            var b = new Boolean();
            console.log(typeof b);           //object
            console.log(b.valueOf());        //false
            console.log(typeof b.valueOf()); //boolean

            var b1 = new Boolean(0);
            console.log(typeof b1.valueOf());//boolean
            var b2 = new Boolean(-0);
            console.log(typeof b2.valueOf());//boolean
            var b3 = new Boolean(undefined);
            console.log(typeof b3.valueOf());//boolean
            var b4 = new Boolean(false);
            console.log(typeof b4.valueOf());//boolean
            var b5 = new Boolean(null);
            console.log(typeof b5.valueOf());//boolean
            var b6 = new Boolean('');
            console.log(typeof b6.valueOf());//boolean

JavaScript中内建对象-String对象

JavaScript中内建对象-Function对象

JavaScript中内建对象-Math对象

JavaScript中对象的属性

JavaScript中对象的原型属性-prototype

            function foo(a,b){
                return a*b;
            }
            console.log(foo.length);      //参数的个数，2
            console.log(foo.constructor); // fucntion Function() { [native code] }
            console.log(foo.prototype);   //Object {}

            function Production(name,color){
                this.name = name;
                this.color = color;
                this.whatAreYou = function(){
                    return 'this is a ' + this.color + ' ' + this.name;
                };

            }

            Production.prototype = {
                price:6888,
                memory:64,
                getInfo:function(){
                    return '内存' + this.memory + '--价钱:' + this.price;
                }

            }
            var p1 = new Production('iPhone6s','玫瑰金'); 
            console.log(p1.name);   //iPhone6s
            console.log(p1.color);  //玫瑰金
            console.log(p1.whatAreYou());//this is a 玫瑰金 iPhone6s
            console.log(p1.price);
            console.log(p1.memory);
            console.log(p1.getInfo()); //内存64--价钱:6888
            //自定义get方法
            Production.prototype.get = function(what){
                return this[what];
            }
            console.log(p1.get('price'));  //6888
            console.log(p1.get('memory')); //64

JavaScript中的扩展内建对象

JavaScript中的原型链继承

JavaScript中的共享属性迁移到原型

JavaScript只继承原型的方案

JavaScript中的继承封装

JavaScript中拷贝父类对象的属性

JavaScript中深度拷贝

JavaScript中的多重继承

JavaScript对象继承总结

其他资料

临海听风V
关注
专栏目录
JavaScript入门教程
09-05
收集整理的JavaScript入门教程，打下良好基础，才能更好的适应后续的jquery、angularjs等框架的学习。
javascript入门资料
02-01
这份"javascript入门资料"提供了学习JavaScript基础知识的途径，对于初学者来说是极好的起点。 首先，JavaScript是一种解释型、弱类型、基于原型的语言，它的主要任务是在用户的浏览器上运行，为网页添加交互性。在...
javascript入门资料资源搜集
SDFS232323的专栏
12-25 115
1、JavaScript 教程 阮一峰 本教程全面介绍 JavaScript 核心语法，从最简单的讲起，循序渐进、由浅入深，力求清晰易懂。 所有章节都带有大量的代码实例，便于理解和模仿，可以用到实际项目中，即学即用。 本教程适合初学者当作 JavaScript 语言入门教程，也适合当作日常使用的参考手册。 来源：https://wangdoc.com/javascript...
JavaScript如何快速学习并入门，各种JavaScript前端学习资料分享
似码非码的博客
05-03 527
Js给初学者的印象总是那么的“杂而乱”，相信很多初学者都在找轻松学习Js的途径。在这里给大家总结一些学习Js的经验，希望能给后来的学习者探索出一条“轻松学习Js之路”。 JavaScript给人的感觉的原因多半是因为它如下的特点： 在这里我还是要推荐下我自己建的web前端开发学习QQ群：682783851，群里都是喜欢分享资源的小伙伴，如果你正在学习前端 ，小编欢迎你加入，今天分享的这个案例已经上...
Object.defineProperty
weixin_44388697的博客
01-23 108
1. 定义属性的两种形式 //1 var obj = {}; obj.name = ‘ming’; //相当于 Object.defineProperty(obj,‘name’,{ value : ‘ming’, writable: true, configurable: true, enumerable: true }) //2 Object.defineProperty(obj,‘name’,{value: ‘ming’}) //相当于 Object.defineProperty(obj,‘name’,
JavaScript 属性描述对象
Bobby的博客
05-27 468
1.概述 JavaScript提供了一个内部数据结构，用来描述一个对象的属性的行为，控制它的行为。这被称为“属性描述对象”（attributes object）。每个属性都有自己对应的属性描述对象，保存该属性的一些元信息 示例： { value: 123, writable: false, enumerable: true, configurable: false, get: ...
javascript入门参考资料.rar
07-09
作为“javascript入门参考资料”这个压缩包，它包含了帮助初学者踏入JavaScript世界的必备资料。 首先，"javascript入门参考资料.ppt"很可能是一个PowerPoint演示文稿，这种格式通常用于教学或讲座，以图文并茂的...
JavaScript入门学习资料包
04-18
总之，这个"JavaScript入门学习资料包"为初学者提供了一个全面学习JavaScript的平台，从基础到高级，从理论到实践，逐步建立起扎实的JavaScript知识体系。通过系统学习和不断实践，你将能够熟练掌握这门强大的编程...
Javascript入门学习资料收集整理篇
01-21
Javascript入门学习第一篇 js基础Javascript入门学习第二篇 js类型Javascript入门学习第三篇 js运算Javascript入门学习第四篇 js对象和数组Javascript入门学习第五篇 js函数Javascript入门学习第六篇 js DOM编程...
JavaScript入门学习书籍推荐
10-30
很多人对学习JavaScript充满热情，但面对市面上琳琅满目的书籍，初学者往往不知如何选择合适的入门书籍。这篇文章将帮助初学者了解推荐的JavaScript学习书籍，并简要介绍每本书的特点。 首先，推荐给新手的书籍是...
javaScript——标准库——属性描述对象
songshuguowang的专栏
02-19 326
概述 JavaScript 提供了一个内部数据结构，用来描述对象的属性，控制它的行为，比如该属性是否可写、可遍历等等。这个内部数据结构称为“属性描述对象”（attributes object）。每个属性都有自己对应的属性描述对象，保存该属性的一些元信息。 下面是属性描述对象的一个例子。 { value: 123, writable: false, enumerable: tru...
js_Object.defineproperty()
palmer_kai的博客
05-03 624
本 post 仿自 MDN MDN_js_Object.defineProperty 在看 vue 的时候，遇到这个方法，所以拿出来看了下，棒棒哒！ Object.defineProperty() static method Object.defineProperty() 方法会直接在一个对象上定义(add)一个新属性，或者修改一个对象的现有属性， 并返回这个对象。 Syntax Ob...
【JS高级】ES5标准规范之严格模式下的保护对象_09
青春木鱼的博客
08-08 386
为什么要保护对象？在普通(旧)的JS对象中，对象的属性值和结构，外界可随意更改，毫无自保和验证能力。ES5中为对象的每个属性都提供了自我保护的机制且ES5中也提供了专门的函数来保护对象的整体结构............
Uncaught TypeError:Cannot redefine property: $router报错解决方案
Coding and studying
01-28 1万+
原因：就如报错提示所描述的，不能重新定义$router，说明是重复定了$router。通常是因为在项目中安装了vue-router的依赖并且用Vue.use()使用了vue-router，还在index.html页面引入了vue-router.js文件。 项目打包优化阶段，为了解决打包成功后，单文件体积过大的问题 ，可以通过 webpack 的 externals 节点，来配置并加载外部的 CDN 资源。 若只在发布阶段配置了externals节点： vue.config.js文件中的配置 co
解决js报错，Cannot read property 'xxx' of undefined
热门推荐
王茂文的博客
09-24 14万+
这是我在使用extjs时候遇到的，实际上这个值我确实给赋值好了，console也能打印出来。 解决办法是：查看所有new过的对象，是否有重复的。不能重复new，新new出来的对象，有些地方没问题，有些时候会出问题！ 比如：复选框勾选的时候，new了俩次，就是俩个事件，然后一直勾选不上，或者报题目中所说的问题。 ...
完美解决了报错：app.js:249 Uncaught TypeError: Cannot redefine property: $router
最新发布
文龙刚的博客
01-12 1090
Cannot redefine property: $router
vue-cli 项目优化时报错 Uncaught TypeError: Cannot redefine property: $router
在下魔王ii的博客
08-10 2850
一定要看到最后，第一部分只是单独针对这个问题的，第二部分是具体项目中的做法 1. 单独处理 这个问题 在优化vue-cli项目时，为了减少文件体积，采用cdn的方式加载了第三方的依赖。 vue.config.js中，在发布模式下配置， //为开发模式 发布模式 分别指定不同的打包入口文件 chainWebpack: config => { // 发布模式 才有必要去配置externals config.when(process.env.NODE_E.
JavaScript入门经典教程解析
"javascript入门教程.pdf，这是一份经典的中文版JavaScript入门教程，包含详细目录，适合初学者阅读和理解。" 在深入探讨JavaScript语言之前，我们先了解它的基本概念和历史背景。JavaScript，作为一种广泛应用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值