javascript知识点

时间：2022-10-05 18:24:02 学习方法我要投稿

相关推荐

javascript知识点

　　学习javascript要掌握哪些知识点?下面是小编整理的一些javascript知识点，希望对你有帮助。

javascript知识点

　　ECMAScirpt中的变量，函数名，操作符都区分大小写。

　　标识符

　　标识符指的可能是：

　　变量名

　　函数名

　　属性名

　　函数的参数

　　标识符的名称：

　　第一个字符只能是字母，下划线_，或者美元符号$;

　　其他的可以是字母，数字，下划线_，或者美元符号$。

　　按照惯例，标识符名称应使用驼峰法，即首字母小写，剩下的每个单词首字母大写。

　　不能把关键字、保留字、TRUE、FALSE、NULL作为标识符名称。

　　注释：

　　//单行注释

　　多行注释

　　严格模式：

　　ES5引入了严格模式，严格模式下，某些旧版本(ES3)的一些不确定行为将得到处理，而对某些不安全的操作也会抛出错误。支持严格模式的浏览器：IE10+ Firefox 4+ Safari 5.1+ Opera 12+ Chrome

　　//在整个脚本中引入严格模式，则在script标签顶部或者*.js文件顶部添加如下代码即可。

　　"use strict";

　　//在指定函数中引入严格模式：

　　function f1(){

　　"use strict";

　　//TODO...

　　};

　　TODO : 引入了严格模式与没引入严格模式的js文件如何解决冲突以及共存?

　　语句：

　　ES中的语句以一个分号结尾，省略分号虽然有效但不推荐。

　　var sum = 1 + 2;

　　关键字与保留字：

　　// 关键字

　　break case catch continue debugger default delete do instanceof else new finally return for switch function this if throw in try typeof var void while with

　　// ES3定义的保留字

　　abstract boolean byte char class const debugger double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile

　　//ES5中非严格模式下的保留字缩减为这些：

　　class enum extends super const export import

　　//ES5中严格模式下的相对非严格模式增加的保留字，其中let与yield是新增的。

　　implements interface let package private protected public static yield

　　//实际开发中，建议将ES3定义的保留字外加新增的let与yield作为参考。

　　需要注意的是，ES5的严格模式下， eval 与 arguments 也不能作为标识符与属性名，否则会抛出错误。

　　变量：

　　ES中的变量是松散类型的，即变量可以保存任何类型的数据。

　　定义变量使用 var 操作符，后跟变量名(即一个标识符)，

　　使用 var 操作符定义的变量会成为该作用域下的局部变量，该变量在函数退出之后就会被销毁：

　　var a; //定义一个名为a的变量，值是undefined

　　var b = null; //定义一个名为b的变量，值为null(空)

　　var c = 'percy'; //定义一个名为c的变量，值为字符串“percy”

　　function f1(){

　　var name = 'jon'; //函数f1()下的局部变量

　　alert(name);

　　}

　　f1(); //jon

　　alert(name); //外部不能直接访问函数的内部变量

　　//使用一条语句定义多个变量，用逗号分隔即可。

　　var name='jon', age=25, isMarried=false;

　　数据类型：

　　ES中有

　　5种简单数据类型(基本数据类型)： Undefined 、 Null 、 Boolean 、 Number 、 String

　　1种复杂数据类型： Object

　　检测给定变量的数据类型 —— typeof 操作符

　　返回值：

　　undefined ——给定的值未定义;

　　boolean ——给定的值是布尔值;

　　string ——给定的值是字符串;

　　number ——给定的值是数值;

　　object ——给定的值是对象或者 null ;

　　function ——给定的是函数;

　　function f2(){

　　console.log('Hi!');

　　}

　　var name = 'jon';

　　var age = 25;

　　alert(typeof f2); //function

　　alert(typeof name); //string

　　alert(typeof age); //number

　　ES数据类型之 Undefined 类型

　　只有一个值： undefined

　　var name;

　　/*var name = undefined;*/ //无需把变量显式设置undefined值

　　alert(name == undefined); //true

　　变量的值为undefined与未声明的变量并不一样，但使用 typeof 操作符均会返回undefined，但输出值时未声明的变量会产生错误：

　　var job; //该变量已声明但未赋值，默认值为undefined

　　// var name2; 该变量并未声明

　　alert(typeof job); //测试变量类型，输出undefined

　　alert(typeof name2); //测试变量类型，即使变量未声明也会输出undefined

　　//输出值时

　　alert(job); //undefined

　　alert(name2); //产生错误：Uncaught ReferenceError: name2 is not defined

　　ES数据类型之 Null 类型

　　只有一个值： null ;

　　undefined 值派生自 null 值，所以用 == 测试两者时会返回 true ;

　　null 值表示一个空对象指针，所以使用 typeof 操作符时会返回 object ;

　　如果创建的变量将来用于保存对象，那么初始声明该变量时应把值设置为 null ;

　　var name = null;

　　alert(typeof name); //object

　　ES数据类型之 Boolean 类型

　　有两个值： true 、 false ;

　　//注意Boolean类型字面值是区分大小写的，True、False以及其他大小写混合的形式均不属于Boolean类型值;

　　var isBoy = true;

　　var isGirl = false;

　　使用 Boolean() 函数把其他值转为Boolean值

　　var name = 'jon';

　　var nameBool = Boolean(name); //true

　　转换规则如下表：

　　数据类型转为true的值转为false的值

　　Boolean true false

　　String 任何非空字符串 “”(空字符串)

　　Number 任何非零数值(包括无穷大) 0，NaN

　　Object 任何对象 null

　　Undefined 不适用 undefined

　　转换规则对于流程控制语句自动执行相应的Boolean转换非常重要：

　　var name = 'jon';

　　if(name){ //name转换为true，执行下面的语句

　　alert('name is defined!');

　　}

　　ES数据类型之 Number 类型

　　TODO

　　ES数据类型之 String 类型

　　TODO

　　ES数据类型之 Object 类型

　　TODO

　　变量, 作用域, 垃圾收集(内存问题)

　　基本类型和引用类型

　　ES中的变量包含基本类型值和引用类型值

　　基本类型值指的是简单的数据段

　　引用类型值值那些可能有多个值构成的对象

　　五种基本数据类型( Undefined, Null, Boolean, Number, String )的值即基本类型值是按值访问的, 因此操作的是保存在变量中实际的值

　　引用类型值是保存在内存中的对象,ES不允许直接访问内存中的位置, 即不能直接操作对象的内存空间. 在操作对象时, 实际上是在操作对象的引用而不是实际的对象.

　　当复制保存在对象中的某个变量时, 操作的是对象的引用 . 但在为对象添加属性时, 操作的是实际的对象 .

　　动态的属性

　　定义基本类型的值和引用类型的值方式是基本一样的, 就是创建一个变量, 然后为该变量赋值 .

　　创建变量以后,基本类型的值和引用类型的值执行的操作有很大不同.

　　//引用类型可以为其添加或删除属性和方法

　　var p = new Object();

　　p.name = "Jon";

　　console.log(p.name); //Jon

　　delete p.name;

　　console.log(p.name); //undefined

　　//基本类型不能添加属性, 因为即使添加了也不能访问

　　var n = "Jon"; //一个string字符串类型

　　n.age = 25;

　　console.log(n.age); //undefined

　　复制变量值

　　复制基本类型值的变量值与复制引用类型值的变量值也存在不同.

　　复制基本类型值时, 是直接创建新值, 占据不同的内存(栈)空间, 复制之后两个变量可以参与任何操作而不互相影响

　　var n1 = 5;

　　var n2 = n1; //复制n1

　　复制引用类型值时, 同样也会把储存在变量对象中的值复制一份到新变量分配的空间中, 但这个新变量的值其实是一个指针, 指向储存在堆中的一个对象. 所以两者引用的是同一个对象. 所以, 改变其中一个变量, 另一个变量也会受到影响.

　　var o1 = new Object();

　　var o2 = o1;

　　o1.name = 'Jon';

　　console.log(o2.name); //o1和o2指向的是堆内存中的同一个对象, 所以同样会输出Jon

　　参数传递

　　ES中所有函数的参数都是按值传递的,不存在引用传递的参数

　　函数外部的值复制给函数内部的参数, 就等于把值从一个变量复制到另一个变量一样.

　　基本类型值的传递就像基本类型变量的复制一样, 向参数传递基本类型值的时候, 被传递的值会被复制给一个局部变量(即命名参数, 用ES的概念来说, 就是arguments中的一个元素)

　　引用类型值的传递就像引用类型变量的复制一样, 向参数传递引用类型值的时候, 会把这个值在内存中的地址复制给一个变量 , 因此这个局部变量的变化会反映在函数的外部

　　function addTen(n){ //参数(这里是n)其实是函数的局部变量

　　n += 10;

　　return n;

　　}

　　var c = 20;

　　var r = addTen(c); //调用时,c作为一个局部变量传递给n,函数体内又会自増10然后返回

　　console.log(c); //外部的c变量不会被影响,还是20

　　console.log(r); //30

　　function setName(obj){

　　obj.name = "Jon";

　　}

　　var p = new Object(); //创建了一个对象并保存在变量p中

　　setName(p); //随即被传递到setName()中,p复制给了obj

　　console.log(p.name); //所以obj的属性name也能被p访问到,所以这里输出Jon

　　//证明对象是按值传递的例子

　　function setName(obj){

　　obj.name = 'Jon';

　　obj = new Object(); //为obj重新定义了一个对象

　　obj.name = 'Percy'; //然后为obj定义了另一个name属性

　　}//如果p是引用传递的话, 那么p就会自动被修改为指向其name属性值为Percy的对象,但下面的例子输出的仍然是Jon. 说明即使函数内部修改了参数的值, 但原始的引用仍然保持不变.

　　var p = new Object();

　　setName(p);

　　console.log(p.name); //Jon

　　可以吧ES函数的参数想象成局部变量.

　　检测类型

　　typeof — 检测变量是哪种基本数据类型 . string , number , boolean , undefined , object (如果变量的值是一个对象或null, 则返回object)

　　console.log(typeof "Jon"); //string

　　console.log(typeof true); //boolean

　　console.log(typeof 1); //number

　　var a;

　　console.log(typeof a); //undefined

　　console.log(typeof null); //object

　　var o = new Object();

　　console.log(typeof o); //object

　　instanceof — 检测引用数据类型值时, 检测其引用数据类型值是什么类型的对象

　　result = variable instanceof constructor

　　如果变量是给定引用类型的实例, 那么instanceof操作符就会返回true

　　console.log(person instanceof Object); //变量person是Object吗?

　　console.log(colors instanceof Array); //变量colors是Array吗?

　　console.log(pattern instanceof RegExp); //变量pattern是RegExp吗?

　　所有引用类型的值都是Object的实例, 所以检测一个引用类型的值和Object构造函数时会始终返回true

　　使用instanceof操作符检测基本类型的值会始终返回false, 因为基本类型不是对象

　　执行环境, 作用域

　　执行环境定义了变量或函数是否有权访问的其他数据.

　　全局执行环境是最外围的执行环境(Web浏览器中指的是window对象),因此所以全局变量和函数都是作为window对象的属性和方法创建的.

　　每个函数都有自己的执行环境, 当执行流进入一个函数时, 函数的环境就会被推入一个环境栈中, 函数执行之后, 栈将其环境弹出, 把控制权返回给之前的执行环境.

　　代码在一个环境中执行时, 会创建变量对象的一个作用域链 , 它保证了对执行环境有权访问的所有变量和函数的有序访问.

　　全局执行环境的变量对象始终都是作用域链中的最后一个对象

　　var color = "blue";

　　function changeColor(){

　　if(color === "blue"){

　　color = "red";

　　}else{

　　color = "blue";

　　}

　　changeColor();

　　console.log("Now color is : " + color);

　　//Now color is : red

　　//函数changeColor()的作用域链包含两个对象,它自己的变量对象和全局环境的变量对象.

　　//内部环境可以通过作用域链访问所有的外部环境, 但外部环境相反不能访问内部环境的任何变量和函数

　　var color = "blue";

　　function changeColor(){

　　var anotherColor = "red";

　　function swapColors(){

　　var tempColor = anotherColor;

　　anotherColor = color;

　　color = tempColor;

　　//这里可以访问color, anotherColor, tempColor

　　}

　　swapColors();

　　//这里只可以访问color, anotherColor

　　}

　　changeColor();

　　////这里只可以访问color

　　alert("Color is now " + color);

　　没有块级作用域

　　if(true){

　　var color = "blue";

　　}

　　console.log(color); //ES中, 在外部依然能访问块级作用域内的变量和函数

　　for (var i=0; i < 10; i++){

　　doSomething(i);

　　}

　　alert(i); //可以访问块级作用域内的变量,输出10

　　//ES中查询标识符会从正在执行的局部环境查找, 如果当前局部环境查找不到, 就会沿着作用域链一级一级向上查找. 如果在全局环境都找不到需要查找的标识符, 说明该变量未声明

　　var color = "blue";

　　function getColor(){

　　return color;

　　}

　　console.log(getColor()); //这里会先搜索getColor()内部有没有color变量, 如果没有就向上一级查找, 直到查找到位置, 这里在上一级已经找到, 所以会输出blue

　　var color = "blue";

　　function getColor(){

　　var color = "red";

　　return color;

　　}

　　console.log(getColor()); //red , 同级找到就不会再向上查找

　　垃圾收集

　　标记清除

　　ES中, 当变量进入环境(例如, 在函数中声明一个变量时), 就把这个变量标记为"进入环境", 这种进入环境的变量从逻辑上讲不能释放其内存, 因为有可能用到它们. 而当变量离开环境时, 就将其标记为"离开环境".

　　过程 :

　　垃圾收集器运行的时候会给储存在内存中的所有变量都加上标记(可以使用任意可使用的标记方式)

　　接着会去掉环境中的变量, 以及被环境中的变量引用的变量的标记(个人理解就是当前执行环境的变量以及被环境中变量引用的变量的标记)

　　在此之后再被加上标记的变量, 就是被视为准备删除的变量(因为它们之前用的时候已经被标记一次了, 再次(第二次)标记说明已经使用完毕), 环境中的变量已经无法访问这些变量了

　　垃圾收集器完成内存清除工作, 销毁那些带标记的值并回收它们所占用的内存空间

　　引用计数

　　引用计数的含义是跟踪记录每个值被引用的次数

　　声明了一个变量并将一个引用类型值赋值给该变量时, 则这个值的引用次数就是1

　　该引用类型值又赋值给另一个变量, 则引用次数加1

　　相反, 如果包含对这个值的引用的变量(如 a 变量)又取得了另一个引用类型值, 则前一个引用类型值的引用次数减1

　　当这个引用类型值的引用次数变成0时, 则说明没办法再访问这个值了, 因而可以将其回收, 释放内存空间

　　该垃圾收集机制早期的循环引用问题

　　function problem(){

　　var oA = new Object();

　　var oB = new Object();

　　//oA与oB通过各自的属性互相引用, 在标记清除的回收机制中, 它们的引用次数永远不可能是0, 并且如果这个函数重复多次调用, 会导致大量内存得不到回收

　　//所以这种方式已经被摒弃, 而采用标记清除来实现其垃圾回收

　　oA.someOtherObject = oB;

　　oB.anotherObject = oA;

　　}

　　IE中的BOM与DOM使用引用计数来作为垃圾收集机制的问题

　　var element = document.getElementById("some_element");

　　var myObject = new Object();

　　//DOM元素(element)与一个原生JS对象(myObject)之间创建了循环引用

　　myObject.element = element; //myObject的element属性指向element对象

　　element.someObject = myObject; //变量element也有一个属性名叫someObject回指myObject

　　//基于上述问题, 即使将力争中的DOM从页面中移除, 它也永远不会被回收

　　//解决方案是在他们不使用时手动断开原生JS对象与DOM元素之间的链接

　　//把变量设置为null意味着断开变量与它之前引用的值之间的链接, 当下一次的垃圾回收执行时, 就会删除这些值并回收他它们占用的内存

　　myObject.element = null;

　　element.someObject = null;

　　//IE9以上已经把DOM和BOM转换成了真正的JavaScript对象, 所以避免了上述问题

　　性能问题及内存管理

　　性能问题

　　早期的浏览器按内存分配量运行的, 达到一个临界值就会触发垃圾回收机制, 这个问题在于, 如果一个脚本中包含大量的变量, 那么会在其生命周期也保持有那么多变量, 导致长时间处于垃圾回收机制的临界值, 从而使垃圾回收机制频繁运行, 造成严重的性能问题.

　　新版本的浏览器已经将其垃圾回收机制的工作方式改变, 会动态的调整触发的临界值.

　　内存管理

　　优化内存占用的方式, 就是为执行中的代码只保存必要的数据. 一旦数据不再有用, 就通过将其值设置为null来释放引用 — 即解除引用

　　function createPerson(){

　　var localPerson = new Object();

　　localPerson.name = name;

　　return localPerson;

　　}

　　var globalPerson = createPerson("Jon");

　　//手动解除globalPerson的引用

　　globalPerson = null;

【javascript知识点】相关文章：

物理知识点11-15