JavaScript学习(1)之JavaScript基础

五.3 检验属性

(1)hasOwnProperty()方法能够检查实验给定属性存在于对象实例中时,则赶回true。

function Student() {

}

Student.prototype.work = "game";

var stu = new Student();
stu.name = "AlphaGL";
stu.age  = 18;

console.log(stu.hasOwnProperty("name")); // true
console.log(stu.hasOwnProperty("work"))  // false

(2)in操作符会访问对象的给定属性,无论该属性是存在于实例中依旧原型中都回到true。

function Student() {

}

Student.prototype.work = "game";

var stu = new Student();
stu.name = "AlphaGL";
stu.age  = 18;

console.log("name" in stu); // true
console.log("work" in stu)  // true
七.二.壹 原型的选取
function Student(name, age) {
    this.name = name;
    this.age = age;

    this.getName = function() {
        return this.name;
    }
}

var student1 = new Student("张三", 18);
var student2 = new Student("李四", 18);

console.log(student1.getName == student2.getName);      // false

上边,成立八个例外的靶子实例,getName完毕了平等的效益,却每种对象中都保存了一份,形成不须要的荒废。那就供给经过原型prototype来缓解此主题材料了。

function Student(name, age) {
    this.name = name;
    this.age = age;

    Student.prototype.getName = function() {
        return this.name;
    }
}

Student.prototype.country = "china";

var student1 = new Student("张三", 18);
var student2 = new Student("李四", 18);

console.log(student1.getName == student2.getName);      // true
console.log(student1.country);                          // china
console.log(student2.country);                          // china

陆.三 函数的习性

眼前提到过,每一种函数都是Function类型的实例,由此也如出一辙享有属性和措施。函数有以下相比常用的习性。

function foo(p1, p2 , p3) {
    console.log(arguments.length);
    console.log(arguments.callee.length);
}

console.log(foo.name);          // foo
console.log(foo.length);        // 3
foo(1, 2);                      // 2 3

由上能够:
foo.name:函数的名号。
foo.length:形参的个数。
arguments.length:实参的个数。
arguments.callee.length:形参的个数。

2.2 标识符

此间的标志符,统指变量名、函数名、属性名以及函数参数的名字。那么,标志符的命名有以下规则:(这一个规则跟C、Java等语言类似)

  • 先是个字符必须是三个假名、下划线_抑或欧元符号$
  • 其他字符则足以是字母、数字、下划线和英镑符号。
  • 不可能动用主要字、保留字来定义标记符。例如:if、for等。

注:在JavaScript中,变量名、函数名甚至操作符等是分别轻重缓急写的。即name和Name代表的是五个不等的变量。

3.5 undefined

在选用var注明变量但未对其初阶化时,该变量的值即为:undefined。undefined类型也惟有那一个值。

字面值undefined紧要用以相比较。

var i = undefined;
console.log(i == undefined); // true

未起初化的变量与未阐明的变量

var foo;
console.log(foo); // undefined
console.log(bar); // 报错

var foo;
console.log(typeof(foo)); // undefined
console.log(typeof(bar)); // undefined

选取typeof操作符来检查评定未早先化的变量与未表明的变量,都重临undefined。

6.4 闭包

闭包(closure)是函数型语言的几个首要的特征,大多高端天性都凭借闭包来完结。闭包,是创造在三个函数内部的函数,能够访问函数内部的变量,并保留在内部存款和储蓄器中,记录上次运转的结果,即保存了创建时的上下文环境新闻。因而,能够简轻便单计算为:

闭包=函数内部创设的函数 + 该函数创立时的上下文环境消息

例如:

function counter() {
    var count = 0;
    return function() {
        return count++;
    }
}

var foo = counter();
console.log(foo());         // 0
console.log(foo());         // 1
console.log(foo());         // 2

闭包的那种机制,就落实面向对象的卷入提供了支撑。将个人变量封装在个中,提供外包接口函数,来访问该变量。

构造函数
函数内部属性
函数的成效域
reduce

四、流程序调控制与运算符

3.2 String

(一)String类型字符串是由单引号或双引号包含的零个或多个字符类别。

var key = "hello";
var value = 'world';

(二)字符串能够像数组同样访问,但假若字符串的值明确了,就不能退换。

var foo = "Java";
foo[0] = "S";
console.log(foo); // Java

foo = foo + "Script";
console.log(foo); // JavaScript

(3)toString()与String

var a = 5;
var b = false;
var c = "AlphaGL"
var d = new Date();

console.log(a); // 5
console.log(b); // false
console.log(c); // AlphaGL
console.log(d); // 2017-05-12T05:54:30.547Z

console.log(String(5));         // 5
console.log(String(false));     // false
console.log(null);              // null
console.log(undefined);         // undefined

还有部分常规的String操作的api,能够查阅JavaScript的String api文书档案。

2.6 变量

可以采纳var根本字来定义变量,JavaScript的变量可以用来保存任何项目标数码。例如:

var name = "AlphaGL";
    name = 18;
    name = function() {
    };

也得以行使逗号来定义八个变量。例如:

var name = "AlphaGL",
    age = 18,
    work = true;

即便JavaScript帮忙那种写法,1般不引入。不仅可读性差,而且易出错。

在函数内表明的变量,那么该变量的成效域为该函数内。例如:

function test() {
    var name = "AlphaGL";
}

test();
console.log(name); // ReferenceError: name is not defined

就算如此能够去掉var申明来解决这一个主题素材,例如:

function test() {
    name = "AlphaGL";
}

test();
console.log(name);

此刻,name就成了全局变量。一般不推荐那种做法。全局变量难以保障,而且便于形成协会混乱。

5.4 删除属性

delete运算符能够用来删除对象的自有总体性,不会去除原型的同名属性,删除不存在的习性在指标上,delete将不会起效果,但仍会回去true。成功删除的时候会回去true,不然再次来到false。

function Student() {

};

Student.prototype.name = "hello";

var stu = new Student();
stu.name = "AlphaGL";
stu.age = 18;

console.log(delete stu.name); // true
console.log(delete stu.name); // 什么不做,同样返回true
console.log(stu.name);        // hello

3、数据类型

JavaScript中数据类型首要有:Number、String、Boolean、Object、undefined、null那两种档次。以及涉及到项目剖断时会用到的操作有:typeof、instanceof、Object.prototype.toString。

四.2.4 位运算符

位运算是比较低层次的运算,按内部存款和储蓄器中表示数值的位来操作数值。JavaScript中有着的数值都以以6三人格式存款和储蓄,而位操作符是先将陆十三位的值转变到三二10人的平头,然后实践操作,最终再将结果转变回60位。

对此有号子的平头,3第22中学的前三11个人代表整数的值,第二十二个人表示数值的号子,用0代表整数,一代表负数,因而第壹3人也叫符号位。个中,正数是以二进制格式存储的,负数2进制补码的样式储存的。

(一)原码、反码和补码
原码,是该数值的暗号位与相对值的二进制表示。例如:

2[原码]:  0000 0000 0000 0000 0000 0000 0000 0010
-2[原码]: 1000 0000 0000 0000 0000 0000 0000 0010

反码,正数的反码是其原码。负数的反码,是符号位不改变,其他各位取反,即一变成0,0产生壹。例如:

2[反码]: 0000 0000 0000 0000 0000 0000 0000 0010
-2[反码]:1111 1111 1111 1111 1111 1111 1111 1101

补码,正数的补码是其原码。负数的补码,是其反码加1。例如:

2[补码]: 0000 0000 0000 0000 0000 0000 0000 0010
-2[补码]:1111 1111 1111 1111 1111 1111 1111 1110

(2)按位与(&)
按位于,是将多少个操作数的贰进制位对齐,当七个数值的位都为一时,结果为1,任意三个为0,则结果为0。

console.log(3 & 5); // 1

3 = 0000 0000 0000 0000 0000 0000 0000 0011
5 = 0000 0000 0000 0000 0000 0000 0000 0101
& = 0000 0000 0000 0000 0000 0000 0000 0001

(3)按位或(|)
按位或,是将七个操作数的二进制位对齐,当七个数值的位任意一个为一时,结果为1,多个都为0,则结果为0。

console.log(3 | 5); // 7

3 = 0000 0000 0000 0000 0000 0000 0000 0011
5 = 0000 0000 0000 0000 0000 0000 0000 0101
| = 0000 0000 0000 0000 0000 0000 0000 0111

(4)按位非(~)
按位非,是得到该数值的反码。

console.log(~3); // -4

3 = 0000 0000 0000 0000 0000 0000 0000 0011
~ = 1111 1111 1111 1111 1111 1111 1111 1100

(5)按位异或(^)
按位异或,是将五个操作数的二进制位对齐,当多个数值的位在这之中只有三个为一时,结果为一,五个都为0或都为1,则结果为0。

console.log(3 ^ 5); // 6

3 = 0000 0000 0000 0000 0000 0000 0000 0011
5 = 0000 0000 0000 0000 0000 0000 0000 0101
^ = 0000 0000 0000 0000 0000 0000 0000 0110

(6)左移(<<)
左移,是将操作数的有所位移动内定的位数,右边多出的位用0填充。左移不影响操作数的符号位。

console.log(3 << 2);    // 12
console.log(-3 << 2);   // -12

3    = 0000 0000 0000 0000 0000 0000 0000 0011
<< 2 = 0000 0000 0000 0000 0000 0000 0000 1100

(7)有暗记右移(>>)
有暗号右移,是将操作数的享有位移动钦命的位数,并保存符号位。左边多出的位用0填充。

console.log(12 >> 2);   // 3
console.log(-12 >> 2);  // -3

12   = 0000 0000 0000 0000 0000 0000 0000 1100
>> 2 = 0000 0000 0000 0000 0000 0000 0000 0011

(8)无符号右移(>>>)
无符号右移,是将操作数的兼具位移动钦赐的位数。对刘恒数,无符号右移与有旗号右移结果同样,负数会以补码的方式右移钦命的位。

console.log(12 >>> 2);   // 3
console.log(-12 >>> 2);  // 1073741821

5、对象

在介绍数据类型的时候关系过,在JavaScript中指标是1组冬日的键值对聚集,类似别的语言的HashMap、Dictionary等数据结构。除数字、true、false、null、undefined和字符串外,全部的值都以指标。JavaScript内置了Object、Date、Array、Function、RegExp等目的。全体指标承接Object对象。

5.二 读取属性

能够通过点(.)大概中括号([])的点子赢得对象属性的值。

(1)通过点(.)来获取

var student = {
    name : "AlphaGL",
    age  : 18
};

console.log("name = " + student.name); // name = AlphaGL

(二)通过中括号访问属性的值,中括号内可以是变量且计量结果必须是字符串的表达式。借使属性名包涵回导致语法错误的字符,或然属性名使用的是首要字可能保留字,也足以利用中括号表示。

var name = "nick name";
student[name] = "AlphaGL"; // 等价于 student["nick name"] = "AlphaGL";

貌似推荐使用点的点子去获得对象属性。

壹.二 JavaScript应用范围

web前端:最近比较火的Vue.js、React、 Angular等等前端框架屡见不鲜。
手机app:React
Native、PhoneGap、Weex等跨平台活动框架等,以及微信小程序等。
打闹引擎:Cocos二d-js、Unity、egret等引擎都帮助JavaScript脚本语言。
服务器:pomelo、Node.js等。

7.2.3 isPrototypeOf与instanceof
function A() {
}

function B() {
}

var a1 = new A();
console.log(a1 instanceof A);                       // true
console.log(a1 instanceof B);                       // false
console.log(A.prototype.isPrototypeOf(a1));         // true
console.log(B.prototype.isPrototypeOf(a1));         // false

A.prototype = {};
var a2 = new A();
console.log(a1 instanceof A);                       // false
console.log(a2 instanceof A);                       // true
console.log(A.prototype.isPrototypeOf(a1));         // false
console.log(A.prototype.isPrototypeOf(a2));         // true

B.prototype = new A();
var a3 = new B();
console.log(a3 instanceof  A);                      // true
console.log(a3 instanceof  B);                      // true
console.log(B.prototype.isPrototypeOf(a3));         // true
console.log(A.prototype.isPrototypeOf(a3));         // true

通过以上实例能够总结如下:

  • object instanceof constructor
    运算符,用来检验constructor.prototype是还是不是存在于参数object的原型链。固然,右操作数是构造函数,但实则检测了对象的存在延续关系,而不是检查评定创制对象的构造函数。

  • prototypeObj.isPrototypeOf(object)
    自作者批评二个目的是否存在于另多少个对象的原型链上。能够掌握为object对象是还是不是延续自prototypeObj.prototype。

3.4 Object

对象是JavaScript中首要的数据类型,除数字、true、false、null、undefined和字符串外,全体的值都以指标。在JavaScript中目的是壹组严节的键值对聚集,类似别的语言的HashMap、Dictionary等数据结构。上边会有单独一小节来专门讲述下对象。

4.2 运算符

JavaScript中运算符大体可分为,算术运算符、关系运算符、逻辑运算符以、位运算符以及其它操作符等,当然也包罗运算符重载。

  • 算术运算符:+-*/%++--+=-=*=/=%=等。
  • 关系运算符:<><=>======!=!==
  • 逻辑运算符:&&||!
  • 位运算符:~&|^<<>>>>>
  • 其余操作符:=,?=

2.5 语句

JavaScript中每条语句都以以总局结尾,但分号不是不可或缺的。但建议是决不轻巧分号,来幸免如不完整的输入等主题素材。语句块用花括号包罗。

2.四 严酷格局

启用严苛形式,会对一些不分明的行为或不安全的操作抛出荒唐。在本子的顶部增加如下字符串:

"use strict";

也得以加上到函数内部,来钦赐该函数在从严情势下实施。

2.1 语法

JavaScript语法中山高校量借鉴了C和Java、Perl等语言的语法,由此熟识这一个语言的人再来学习JavaScript会倍感似曾相识。但JavaScript与Java是五遍事,JavaScript完全是蹭了当初Java的光热,来推进协调。

一个整机的JavaScript完结由上面多少个例外的局地组成:

  • 核心(ECMAScript)
  • 文书档案对象模型(DOM)
  • 浏览器对象模型(BOM)

ECMAScript:
概念了语言的根基,规定并对该语言在语法、类型、语句、关键字、保留字、操作符、对象等方面作了现实描述,并不带有输入和出口。

DOM:
文书档案对象模型(Document Object
Model)是XML和HTML的编制程序接口。DOM会把全路页面映射为二个多层节点结构树,程序能够对协会树实行加多、删除、替换或改动任何节点。

BOM:
浏览器对象模型(Browser Object Model)帮助访问和操作浏览器窗口。

注:以下描述就不区分ECMAScript和JavaScript,也不简称js,均统称JavaScript。

四.贰.贰 关系运算符

用来剖断一个操作数是还是不是超过或低于或等于其它一个操作数。

console.log(2 < 3);                     // true
console.log("12" < 3);                  // false
console.log("12" < "3");                // true               
console.log("Alpha" < "alpha");         // true
console.log("AlphaGL" < "AlphagL");     // true
console.log(2 < "AlphaGL");             // false
console.log(2 < true);                  // false
console.log(2 < undefined);             // false
console.log(2 < null);                  // false
console.log(2 < NaN);                   // false
console.log(false < true);              // true
console.log(2 < Infinity);              // true              
console.log(2 < -Infinity);             // false
console.log(Infinity < Infinity);       // false
console.log(Infinity < Infinity + 1);   // false
console.log(0 <= 0);                    // true
console.log(0 >= 0);                    // true
console.log(12 == "12");                // true
console.log(12 === "12");               // false
console.log(12 !== "12");               // true
console.log(undefined == 0);            // false
console.log(undefined == null);         // true
console.log(undefined == false);        // false
console.log(null == false);             // false
console.log(null == 0);                 // false
console.log("" == 0);                   // true
console.log(undefined == "");           // false
console.log(2 != NaN);                  // true
console.log(NaN == NaN);                // false
console.log(NaN != NaN);                // true
console.log(false == 0);                // true
console.log(true == 1);                 // true

综上,关系运算符重返的都以boolean值,有以下规则:

  • 倘诺相比较的多个操作数都以数值,则举行数值比较。若是唯有叁个操作数是数值,则将其它多少个操作数调换为数值,再奉行数值比较。
  • 若果相比的多个操作数都以字符串,则相继比较字符串每一种字符的Unicode值。
  • 假诺有3个操作数是NaN,则实践结果为false,推行不对等操作时,执行结果为true。
  • null和undefined相等。但不可能将null和undefined转化为其余任何值。
  • 如若有一个操作数是指标,其余3个操作数不是,则会调用对象的valueOf方法获得原始值,再利用方面包车型客车平整。
  • 当八个操作数的值同样,类型也如出1辙,并且都不是NaN时,则七个操作数全等(===)。当比较的八个操作数调换为同样种类后的值万分,则五个操作数相等(==)。

3.3 Boolean

该类型唯有七个字票面价值:true和false。供给重申的是,true不一定是1,false也不分明是0。其它类型调换来Boolean类型时,有弹指间规则:

  • Boolean
    true转换成true,false转换成false。
  • String
    任何非空字符串转换到true,空字符串(“”)调换来false。
  • Number
    其他非零数字值(包罗无穷大)转变来true,0和NaN调换来false。
  • Object
    别的对象转变来true,null调换到false。
  • Undefined
    undefined转换成false。

    console.log(Boolean(“AlphaGL”)); // true
    console.log(Boolean(“false”)); // true
    console.log(Boolean(“”)) // false
    console.log(Boolean(10)); // true
    console.log(Boolean(Infinity)); // true
    console.log(Boolean(-Infinity)); // true
    console.log(Boolean(0)); // false
    console.log(Boolean(NaN)); // false
    console.log(Boolean(new Date())); // true
    console.log(Boolean(null)); // false
    console.log(Boolean(undefined)); // false

综上:当班值日为0,null,false,NaN,undefined,空字符串(“”)转变来Boolean类型时值都为false,其余任何值都为true。

以下实例:

(1)

var x;
if (x) {
    console.log("test1")
}else {
    console.log("test2")
}

输出:test2

(2)

var x = null;
if (x) {
    console.log("test1")
}else {
    console.log("test2")
}

输出:test2

(3)

var x = Boolean(false);
if (x) {
    console.log("test1")
}else {
    console.log("test2")
}

输出:test2

(4)

var x = false;
if (x) {
    console.log("test1")
}else {
    console.log("test2")
}

输出:test2

(5)

var x = new Boolean(false);
if (x) {
    console.log("test1")
}else {
    console.log("test2")
}

输出:test1

综上:任何值不为undefined也许null的目的, 包罗值为false的Boolean对象,
在标准化语句中,其值都将用作true来判别。

陆.2 函数的参数与其间属性

JavaScript中等高校函授数定义尚无点名函数参数的档次,调用时也未对实参的值做项目检查,一样也不检查参数个数。

2、基本概念

四.1.二 循环语句

(1)while语句
while循环包涵循环条件和循环体,当循环条件满足条件时,才会举办循环体内的代码块。

while(expression) {
    statement;
}

while(i < 100) {
    i++;
}

(2)for语句
for语句一般包括初步标准、循环条件、循环递增(递减)语句3有些。

for(initialization; expression; post-loop-expression) {
    statement;
}

for(var i = 0; i < 100; i++) {
    console.log(i);
}

(3)for-in语句
该语句看似于其余语言的foreach语句,可以用了遍历容器结构或对象的性质。

for (property in expression) {
    statement;
}

var o = [1, 2, 3];
for(var i in o) {
    console.log(o[i]);
}

(4)do-while语句
do-while语句与while语句看似,不一致的时,do-while语句会先执行循环体,再检查测试循环条件,那就象征该循环语句至少会实施壹遍。

do {
    statement;
}while(expression);

(5)break与continue
break和continue都可用于调节循环中代码的施行。
break:立即退出循环。
continue:跳出当前巡回,继续实行下次巡回。

参考:

MDN
JavaScript教程

肆.一.一 条件语句

(1)if语句

if (condition1) {
    statement1;
}else if(condition2) {
    statement2;
}else {
    statement3;
}

该协会,当条件1(condition1为true)满意时,实行语句一(statement壹),不然条件二(condition二为true)满足时,实施语句②,以上都不满意则奉行语句三(statement三)。

这里的else if能够有零个或两个,甚至else都以可选的,依照真实情况来加强际判定。

if (i > 0) {
    console.log("i大于0");
}else if(i < 0) {
    console.log("i小于0");
}else {
    console.log("i等于0");
}

(2)switch语句
switch是一种多分支组织,与if结构类似,也是1种常见接纳的流程序调节制语句。

switch(expression) {
    case value1:
        statement1;
        break;
    case value2:
        statement2;
        break;
    default:
        statement3;
}

当表明式(expression)的值,等于对应case的值(value),则会执行相应的语句块(statement),break用于跳出该switch结构,若省略break,则会继续实践下1个case。default用于以上表明式的值都不满意条件。

表达式(expression)能够选拔其余数据类型,包罗字符串、对象。case的值(value)也得以是变量、表明式,不自然是常量。这一点与其余部分言语区别,只好选用数值。

七.2 原型与后续

每一个对象都有1个私房属性(prototype)原型,该属性指向该对象的原型对象。能够领略为别的编程语言中的,指向基类或许父类的法力。当然,该原型对象同样有一个友好的prototype,层层升高直到该目的的原型为null。null未有原型。JavaScript中差不多具有的目的都是放在原型链顶端的Object的实例,同样能够领略为,都以Object的子类。因而,使用原型对象足以让全部指标实例共享它所富含的天性和情势。

2.3 注释

单行注释使用//。例如:

// 这是一个单行注释

多行注释使用/***/结构。例如:

/*
 * 这是一个多行注释
 */
陆.2.一 函数的参数
function foo(p1, p2, p3) {
    return p2;
}

console.log(foo(1));                // undefined
console.log(foo(1, 2));             // 2
console.log(foo(1, 2, 3));          // 2
console.log(foo(1, 2, 3, 4));       // 2

当形参与实参的个数不相称时,少的参数将被置为undefined,多的参数将被丢掉。

六.二.贰 函数的在那之中属性

在函数内部,有个独特的靶子arguments。该目标用来保存函数参数,能够像数组样使用数字索引来访问参数,同样它也包含length属性。但它并不是确实的数组。此外,该对象还富含callee属性,该属性指向拥有这么些arguments对象的函数。

function foo(p1, p2, p3) {
    console.log(arguments.length);      // 3
    console.log(arguments[0]);          // 第一个参数,即:1
    console.log(arguments[1]);          // 第二个参数,即:2
    console.log(arguments[2]);          // 第三个参数,即:3
}

foo(1, 2, 3);

使用arguments和callee:

function sum(p) {
    if (p <= 1) {
        return 1;
    }else {
        return p + arguments.callee(p -1);
    }
}

console.log(sum(5));        // 15

3.7 typeof、instanceof与Object.prototype.toString

由于JavaScript是动态类型的,因而就须要1种手腕来检查实验给定的变量的切实数据类型。

(1)typeof
typeof操作符重临的值是以下某些字符串:

  • “undefined”
  • “boolean”
  • “string”
  • “number”
  • “object”
  • “function”

    console.log(typeof(123)); // number
    console.log(typeof(“123”)); // string
    console.log(typeof(NaN)); // number
    console.log(typeof(Infinity)); // number
    console.log(typeof(false)); // boolean
    console.log(typeof(null)); // object
    console.log(typeof([])); // object
    console.log(typeof({})); // object
    console.log(typeof(function(){})); // function
    console.log(typeof(undefined)); // undefined

(二)instanceof:下文少禽商讨。
(3)Object.prototype.toString:下文仲斟酌。

1、JavaScript概述以使用范围

7.二.贰 访问属性规则
function A() {

}

A.prototype.name = "小明";
A.prototype.age = 18;
A.prototype.country = "china";

function B() {
}

B.prototype = new A();
B.prototype.name = "小李";
B.prototype.age = 20;

function C() {

}

C.prototype = new B();
var c = new C();
c.name = "小赵";
c.country = "shanghai";

console.log(c.country);         // shanghai
console.log(c.age);             // 20
console.log(c.name);            // 小赵

当访问对象的某部属性时,会依据给定的习性名称来搜寻。纵然,在该对象的实例中找到该属性,则赶回属性的值;不然,则延续搜寻该对象的原型对象,在原型对象中搜寻该属性,依次百余年不遇进步寻觅,直到寻找到原型链的末尾。由此,对象的属性会覆盖同名的该目的的原型对象的同名属性。

7.壹 构造函数

前边提到过,使用new关键字调用构造函数能够创制二个新对象。

function Student(name, age) {
    this.name = name;
    this.age = age;
    this.setName = function(n) {
        this.name = n;
    }

    this.getName = function() {
        return this.name;
    }
}

var student = new Student("张三", 18);
student.setName("李四");

console.log(student.getName());         // 李四

其间,this关键字指向了,当前要创立的靶子。

伍.壹 对象的开创

指标的创造分为二种方法:
(一)使用new操作符,前边紧跟构造函数

var student = new Object(); // 等价于 var student = {};
student.name = "AlphaGL";
student.age = 18;
student.print = function () {
    console.log("hello AlphaGL");
}

(二)使用对象字面量表示法。由若干名/值对中等用冒号分割,每对名/值对间用逗号分隔组成的映射表。

var student = {
    name : "AlphaGL",
    age  : 18
    print: function () {
        console.log("hello AlphaGL");
    },
};
肆.2.三 逻辑运算符

(1)逻辑与(&&)
在boolean环境下当逻辑与的三个操作数同时为true时,结果才为true,否则为false。

console.log(new Date() && 2);               // 2
console.log(2 && new Date());               // 2017-05-31T02:39:51.033Z
console.log(false && new Date());           // false
console.log(new Date() && new Date());      // 2017-05-31T02:39:51.035Z
console.log(false && 0);                    // false
console.log(true && 0);                     // 0
console.log(2 && 0);                        // 0
console.log(2 && "");                       // ""
console.log(2 && "AlphaGL");                // AlphaGL
console.log(2 && null);                     // null
console.log(2 && undefined);                // undefined
console.log(2 && NaN);                      // NaN
console.log(2 && Infinity);                 // Infinity

综上,逻辑与的选择规则可以计算如下:

  • 只要第三个操作数能转变到false,则赶回第3个操作数,不然重返第三个操作数。在boolean环境中央银行使时,多个操作数结果都为true时,再次来到true,否则重临false。
  • 可见转移为false的值有,0,””,null,undefined。

堵塞操作:
在实施逻辑与操作时,当第三个操作数的结果为false时,就不在实践第1个操作数的求值了。因为无论首个操作数为啥值,其结果都不容许为true。

function test(i) {
    if(i > 0) {
        return i;
    }else{
        return -i;
    }
}

console.log(false && test(2));      // false
console.log(true && test(2));       // 2

(2)逻辑或(||)
在boolean环境下当逻辑或的五个操作数任意多少个为true时,结果都为true。壹般,可用来给变量设置暗中同意值。

console.log(new Date() || 2);               // 2017-05-31T02:46:51.732Z
console.log(2 || new Date());               // 2
console.log(false || new Date());           // 2017-05-31T02:48:51.732Z
console.log(new Date() || new Date());      // 2017-05-31T02:48:51.732Z
console.log(false || 0);                    // 0
console.log(true || 0);                     // true
console.log(2 || 0);                        // 2
console.log(2 || "");                       // 2
console.log(2 || "AlphaGL");                // 2
console.log(2 || null);                     // 2
console.log(2 || undefined);                // 2
console.log(2 || NaN);                      // 2
console.log(2 || Infinity);                 // 2

综上,逻辑或的利用规则能够总计如下:

  • 就算第七个操作数能转变到true,则赶回第三个操作数,不然再次回到第三个操作数。在boolean环境中使用时,两个操作数任意贰个为true时,再次来到true,不然再次回到false。
  • 能够转移为false的值有,0,””,null,undefined。

堵塞操作:
在施行逻辑或操作时,当第贰个操作数的结果为true时,就不在施行第三个操作数的求值了。因为不论是首个操作数为什么值,其结果都不容许为false。

function test(i) {
    if(i > 0) {
        return i;
    }else{
        return -i;
    }
}

console.log(false || test(2));      // 2
console.log(true || test(2));       // true

(3)逻辑非(!)
任由操作数是什么品种的数额,该操作都会回来3个boolean。逻辑非会先将操作数转变为一个boolean,再对齐求反。

console.log(!0);            // true
console.log(!"");           // true
console.log(!NaN);          // true
console.log(!null);         // true
console.log(!undefined);    // true   
console.log(!Infinity);     // false
console.log(!2);            // false
console.log(!"AlphaGL");    // false   
console.log(!new Date());   // false

综上,逻辑非的运用规则能够总计如下:

  • 假如操作数能更动为true的话,则赶回false,否则再次来到false。
  • 可见转移为false的值有,0,””,null,undefined。

5.5 Array对象

JavaScript中,数组算是最常用的品类。数组的大大小小能够动态调控,每壹项能够保存任何项指标多寡,起头项从0初步。还是能够达成货仓,队列等数据结构。

(1)数组的创导

  • 选择Array构造函数创立。
    javascript var nums = new Aarray(3); var names = new Array("foo", "bar") var colors = Array("R", "G", "B")
  • 利用数组字面量表示法。即接纳中括号,并将各类元素用逗号隔断。
    javascript var num = [1, 2, 3]; var names = ["foo", "bar"]; var params = [1.2, "ab", true]; var pos = [{x:1, y:2}, {x:3, y:4}];

(二)数组成分的拜会。

var a = ["AlphaGL", 18, true];
console.log(a[0]);                  // AlphaGL
console.log(a[1]);                  // 18
console.log(a[2]);                  // true
//indexOf返回在数组中可以找到一个给定元素的第一个索引,如果不存在,则返回-1。类似的还有lastIndexOf方法。
console.log(a.indexOf("AlphaGL"));  // 0
console.log(a.indexOf(true));       // 2
console.log(a.indexOf(18));         // 1
console.log(a.indexOf(2));          // -1

console.log(a.length);              // 3
console.log(a[3]);                  // undefined。javascript数组下标从0开始。

可以行使负数或非整数来索引数组。那时,数值将会调换为字符串,而该索引被视作对象的例行属性。若是,使用了非负整数的字符串,则它会被当作数组索引访问,而不是目的属性访问。

var a = ["AlphaGL", 18, true];
console.log(a[-1]);     // undefined
console.log(a[1.5]);    // undefined

console.log(a["1"]);    // 18
console.log(a["2"]);    // true

想见,数组的造访只是对象访问的一种非常格局,当访问不设有的性质时,javascript也不会报错,只会重返undefined值。因而,javascript中数组不设有数组越界的难题。

(三)数组成分的拉长与删除
添新币素:

var a = [];
a[0] = "AlphaGL";
a.push(18, true);

console.log(a);     // [ 'AlphaGL', 18, true ]

删除成分:

var a = ["AlphaGL", 18, true];
delete a[1];
console.log(a[1]);      // undefined
console.log(a.length);  // 3
console.log(a.pop());   // true。从数组中删除最后一个元素,并返回该元素的值
console.log(a.length);  // 2
console.log(a.shift())  // AlphaGL。从数组中删除第一个元素,并返回该元素的值
console.log(a.length);  // 1
a[0] = undefined;
console.log(a.length);  // 1

var a = ["AlphaGL", 18, true];
a.length = 2;
console.log(a[2]);      // undefined
a.length = 0;
console.log(a[0]);      // undefined

var a = ["AlphaGL", 18, true];
a.splice(2, 0, "haha"); // 从第2个元素开始,删除0个元素,即添加元素haha
console.log(a);         // [ 'AlphaGL', 18, 'haha', true ]

a.splice(1, 2);         // 从第1个元素开始,删除2个元素。
console.log(a);         // [ 'AlphaGL', true ]

a.splice(0, 1, "haha"); // 从第0个元素开始,删除1个元素,并添加haha元素。
console.log(a);         // [ 'haha', true ]

注:删除数组成分与将数组成分赋值为undefined值类似。使用delete不是修改数组的length属性,也不会活动后继成分地点。其余操作方法基本都会移动数组成分和退换数组length值。也足以直接操作数组的length属性来到达输出元素的目标。push和pop方法提供了近乎栈结构的操作。push和shift方法则提供了就像队列结构的操作。splice有替换数组中随机数量的项的效能。

(4)数组的检查实验

var a = ["AlphaGL", 18, true];
console.log(Array.isArray(a));      // true
console.log(a instanceof Array);    // true

注:当存在多个以上的全局推行环境时,即存在七个以上分化版本的Array构造函数,instanceof则不得不在单一的大局推行环境有效。

(5)数组的排序

var a = [1, 11, 57, 7, 23];
a.sort(function (p1, p2) {  // 使用比较函数来对数组元素进行排序。返回的值小于0,则p1放到p2位置之前;大于0则p1在p2之后;等于0则位置不变。
    return p1 > p2;
});

console.log(a);     // [ 1, 7, 11, 23, 57 ]

var a = ["AlphaGL", 18, true];
a.reverse();        // 逆序数组。
console.log(a);     // [ true, 18, 'AlphaGL' ]

(陆)数组的遍历与迭代

var a = [1, 11, 57, 7, 23];
var t1 = a.every(function (element, index, array) {
    return element % 2 != 0;
});

var t2 = a.every(function (element, index, array) {
    return element > 10;
});

console.log(t1);        // true
console.log(t2);        // false

注:every方法会对数组中的每一种运营给定函数,假若该函数的各项都回去true,则结果才为true。

var a = [1, 11, 57, 7, 23];
var t1 = a.filter(function (element, index, array) {
    return element % 2 != 0;
});

var t2 = a.filter(function (element, index, array) {
    return element > 10;
});

console.log(t1);        // [ 1, 11, 57, 7, 23 ]
console.log(t2);        // [ 11, 57, 23 ]

注:filter方法会对数组中的每1项运维给定的函数,并回到该函数会再次来到为true的项组成的新数组。

var a = [1, 11, 57, 7, 23];
var t1 = a.forEach(function (element, index, array) {
    array[index] = element + 1;
});
console.log(a);         // [ 2, 12, 58, 8, 24 ]

注:forEach方法同样会对数组中每1项运营给定的函数。该方法未有再次回到值。

var a = [1, 11, 57, 7, 23];
var t1 = a.map(function (element, index, array) {
    if(element > 10) {
        return element + 1;
    }

    return element - 1;
});

console.log(t1);        // [ 0, 12, 58, 6, 24 ]

注:map方法会将每一次运转给定的函数重回的值,组成2个新的数组。

var a = [1, 11, 57, 7, 23];
var t1 = a.some(function (element, index, array) {
    return element > 50;
});

console.log(t1);        // true

注:map方法一样会对数组中的每一项都运营给定的函数,要是该函数的任1项结果为true,则赶回true。

(7)其它
当然,数组还有一部分别的的用法和函数。那里就不1一介绍了。感兴趣的,能够参考文末列举的参考链接。

肆.贰.伍 其余运算符

(一)赋值运算符(=)
赋值能够和其余运算符组合使用。例如:

var x = 3;
console.log(x += 5); // 8

(二)逗号运算符(,)
逗号运算符,能够再一条语句中实行多少个操作。要是,逗号运算符用于赋值,则赶回表明式中的最后1项。

var x = 2, y = 3, z = 5;

var pos = (2, 3, 5);
console.log(z);     // 5
console.log(pos);   // 5

(叁)三目运算符(?=)
3目运算符,格式形如:
variable = boolean_expression ? true_value : false_value

当表明式boolean_expression的值位true时,则返回true_value的值,否则,返回false_value的值。

console.log(1 > 2 ? 1 + 2 : 1 - 2); // -1

3.1 Number

(一)JavaScript中并不区分整型或浮点数,全数数字均统一运用614人浮点数表示。可用Number.MIN_VALUE和Number.MAX_VALUE来获取Number类型的值的限量。

console.log(Number.MIN_VALUE); // 5e-324
console.log(Number.MAX_VALUE); // 1.7976931348623157e+308

(2)NaN
非数值(Not a
Number)是二个异样的数值。当算术运算再次回到三个未定义或不大概代表的值时,就爆发NaN了。

console.log(typeof(NaN));   // number
console.log(0 / 0);         // NaN
console.log("hello" / 5);   // NaN
console.log(NaN + 1);       // NaN

注:0除以0会回来NaN。其余数除以0不会。

看清1个变量是不是是非数值,能够使用isNaN()函数。

console.log(isNaN(NaN));        // true
console.log(NaN == NaN);        // false
console.log(isNaN("hello"));    // true,"hello"不能转换成数值
console.log(isNaN(true));       // false
console.log(isNaN(false));      // false
console.log(isNaN(5));          // false
console.log(isNaN("5"));        // false

注:NaN与别的全体值都不等于,包涵它和谐。由此确定NaN不要用=====

(3)Infinity(正无穷)和-Infinity(负无穷)
JavaScript中还有三个例外的数值Infinity和-Infinity。

console.log(typeof(Infinity));  // number
console.log(typeof(-Infinity)); // number
console.log(1 / 0);             // Infinity
console.log(1 / -0);            // -Infinity

推断2个变量是还是不是是夏朝数,能够利用isFinite()函数。

console.log(isFinite(Infinity));  // false
console.log(isFinite(-Infinity)); // false
console.log(isFinite(NaN));       // false
console.log(isFinite(0));         // true
console.log(isFinite("0"));       // true

1.1 JavaScript概述

率先,JavaScript是1门动态类型的编制程序语言。扶助面向对象、函数式等编制程序范式。同时,它也是运作在宿主环境下的轻量级的脚本语言,例如:浏览器,JavaScript代码可停放到HTML页面中。当然,也有利用基于Node.js的服务器环境。能够说它是主流浏览器都补助的脚本语言,那也作育了JavaScript在PC、手提式有线电话机、平板等环境处理与网页交互时的原始优势。随着HTML5的加大与普及应用,出现了多量基于JavaScript的跨平台框架和娱乐引擎,是向阳全栈开荒很值得学习的一门编制程序语言。正如在编制程序语言界流行着“世界自然是JS的”的槽点,足以可知JavaScript的精锐。

肆.贰.一 算术运算符

(一)加法操作符(+)
加减法操作符时JavaScript中最常用得操作符之壹,与别的语言区别得是,在JavaScript中有一种类特有得行为,使用时应当注意。

console.log(1 + 2);                      // 3
console.log(1 + "2");                    // 12
console.log("1" + "2");                  // 12
console.log(1 + [2]);                    // 12
console.log(1 + "2" + 3);                // 123
console.log("1" + 2 + 3);                // 123
console.log(1 + 2 + "3");                // 33
console.log("1" + 2 + "3");              // 123
console.log(1 + [2, 3]);                 // 12,3
console.log(1 + "");                     // 1
console.log(0.1 + 0.2);                  // 0.30000000000000004
console.log(0.05 + 0.25);                // 0.3

// boolean
console.log(1 + true);                   // 2
console.log(1 + false);                  // 1

// string
console.log("AlphaGL:" + null);          // AlphaGL:null
console.log("AlphaGL:" + undefined);     // AlphaGL:undefined
console.log("AlphaGL:" + Infinity);      // AlphaGL:Infinity
console.log("AlphaGL:" + NaN);           // AlphaGL:NaN
console.log("AlphaGL:" + false);         // AlphaGL:false
console.log("AlphaGL:" + true);          // AlphaGL:true

// infinity
console.log(1 + Infinity);               // Infinity
console.log(Infinity + Infinity);        // Infinity
console.log(1 + (-Infinity));            // -Infinity
console.log((-Infinity) + (-Infinity));  // -Infinity
console.log(Infinity + (-Infinity));     // NaN

// 0
console.log((+0) + (+0));                // 0
console.log((-0) + (-0));                // -0
console.log(0 + (-0));                   // 0

// NaN
console.log(1 + NaN);                    // NaN

console.log(1 + null);                   // 1
console.log(1 + undefined);              // NaN
console.log(1 + (new Date()));           // 1Mon May 25 2017 17:09:08 GMT+0800 (中国标准时间)
console.log(1 + {name: "AlphaGL"});      // 1[object Object]

综上,使用加法操作符能够计算为如下规则:

  • 壹旦四个操作数都以数值,则推行例行得加法总结。这里要求小心浮点数的加法。
  • 假诺一个操作数为字符串,则将别的二个操作数也转化成字符串类型,再实践字符串的拼凑。
  • 假定三个操作数是数值,别的二个操作是Infinity,则加法结果为Infinity。假诺四个操作数是数值,别的3个操作数是-Infinity,则加法结果为-Infinity。若是是Infinity加-Infinity,则加法结果为NaN。假若四个操作数是数值,别的2个操作数是NaN,则加法结果为NaN。
  • 若果多少个操作数是数值,别的二个操作数是boolean,null类型,则先将boolean和null类型转行成原始值,再施行加法运算。
  • 假诺三个操作数是数值,别的三个操作数是指标,则会先调用对象的valueOf办法转化成原始值,如若目的未有valueOf方法,则调用toString方法。

(贰)减法运算符(-)
减法的演算规则与加法类似,那里就不再详细介绍了。

(三)乘法运算符(*)

console.log(2 * 3);                  // 6
console.log(-2 * -3);                // 6
console.log(2 * -3);                 // -6
console.log(2 * Number.MAX_VALUE);         // Infinity
console.log(-2 * Number.MAX_VALUE);        // -Infinity   
// NaN
console.log(2 * NaN);                // NaN
console.log(-2 * NaN);               // NaN
console.log(0 * NaN);                // NaN
console.log(NaN * NaN);              // NaN
// Infinity
console.log(2 * Infinity);           // Infinity
console.log(-2 * Infinity);          // -Infinity
console.log(-2 * -Infinity);         // Infinity
console.log(0 * Infinity);           // NaN
console.log(Infinity * Infinity);    // Infinity
console.log(-Infinity * -Infinity);  // Infinity
// undefined
console.log(2 * undefined);          // NaN
console.log(0 * undefined);          // NaN
console.log(undefined * undefined);  // NaN
// boolean
console.log(2 * false);              // 0
console.log(2 * true);               // 2

console.log(2 * "34");               // 68
console.log(2 * "AlphaGL");          // NaN
console.log(2 * [3, 4]);             // NaN
console.log(2 * {name:"34"});        // NaN
console.log(2 * new Date());         // 2992421935692

综上,使用减法操作符能够计算为如下规则:

  • 三个正数或八个负数相乘,结果为正数。此外有三个操作数为负数,那结果也为负数。要是结果出乎数值的代表范围,则结果为Infinity或-Infinity。
  • 若是有叁个操作数为NaN或undefined,则结果为NaN。
  • 万壹1个非0数值与Infinity或-Infinity相乘,则结果为Infinity或-Infinity,符号取决于操作数的号子和Infinity照旧-Infinity。0与Infinity或-Infinity,则结果为NaN。
  • 即使三个操作数是数值,别的贰个操作数是boolean或许字符串,则先将该操作数转化为原始值,要是转会后的值不是数值,则结果为NaN,不然施行符合规律乘法运算。
  • 倘使一个操作数是数值,其余二个操作数是目的,则结果为NaN。假设是Date对象,则成倍基于当前到196陆年13月八日起的分米数。

(四)除法操作数(/)
除法的运算规则与乘法类似,同样,那里就不再详细介绍了。

(5)模(求余)运算(%)
该运算符是求得除法运算后的余数。

console.log(10 % 3);     // 1
console.log(-10 % 3);    // -1
console.log(10 % -3);    // 1

console.log(10 % 3.14);  // 0.5799999999999996

综上,模运算规则如下:

  • 模运算的结果的标记,与第3个操作数相同。模运算用于浮点数时,结果会有抽样误差。

(6)自增(++)与自减(–)
自增和自减有分为前置和前置。

var x = 5;
var y = ++x - 2
/* 等价于
* var x = 5;
* x = x + 1;
* var y = x - 2;
*/

console.log(x); // 6
console.log(y); // 4

var x = 5;
var y = x++ - 2;
/* 等价于
* var x = 5;
* var y = x - 2;
* x = x + 1;
*/

console.log(x); // 6
console.log(y); // 3

放手自增与前置自增的分别是,前置自增先实行自增,再施行后续的演算,前置自增是先实行运算,再举办自增。同理,自减原理也一样,就不在赘述了。

(7)x op= y操作
这里把+=-=*=/=%=等复合运算统称为op=,那么:

x op= y

绝大大多气象下等价于:
x = x op y

个中,下边那一个表明式中x总括了几遍,在x含有副效能的表明式时,贰者就不等价了。

var c = [1, 2, 3];
var i = 0;
c[i++] *= 2;
console.log(c)
// [ 2, 2, 3 ]

var d = [1, 2, 3];
var j = 0;
d[j++] = d[j++] * 2;
console.log(d);
// [ 4, 2, 3 ]

6、函数

函数,轻便描述就是可另行调用数12遍的作用模块。在JavaScript中,各类函数都是Function类型的实例,因而也一样具有属性和办法。函数名也是指标,能够把函数当作值来行使,那样就提供巨大的灵活性。

JavaScript学习(1)之JavaScript基础

由于工作原因,开垦语言渐渐以JavaScript为主,所以,抽空学习了下JavaScript语法。等如今的劳作稳固性未来,6续会分享下自个儿在求学和支付进程中的壹些经验总计。本着”技多不压身”的规则以及对各样编制程序语言的挚爱,尽管小编平素致力游戏支付工作,也欢腾而又迈进的加盟了JavaScript阵营。

六.一 函数的定义

在JavaScript中,函数的概念有如下两种达成格局:
(一)function关键字+函数名+参数列表+花括号组合的语句块,例如:

function foo(p1, p2) {
    return p1 + p2;
}

console.log(typeof(foo));   // function
console.log(foo(3, 4));     // 7

(二)使用Function构造函数。1般,不推荐那种利用方式。

var foo = new Function("p1", "p2", "return p1 + p2");

console.log(foo(3, 4));     // 7

(3)函数表明式

// 声明了一个匿名函数,并赋值给foo变量。
var foo = function(p1, p2) {
    return p1 + p2;
}

console.log(foo(3, 4));     // 7

// 函数表达式也可以包含名称
var bar = function sum(p) {
    if(p <= 1) {
        return 1;
    }else {
        return p + sum(p - 1);
    }
}

console.log(bar(5));        // 15

// 声明即调用
var sum = function(p1, p2) {
    return p1 + p2;
}(3, 4);

console.log(sum);           // 7

3.6 null

与undefined类似,null类型也只有三个值null。空值null表示2个空的指标指针。

console.log(typeof(null)); // object

null与undefined比较:

console.log(Number(null));          // 0
console.log(Number(undefined));     // NaN

console.log(isNaN(1 + null));       // false
console.log(isNaN(1 + undefined));  // true

console.log(null === undefined);    // false
console.log(null == undefined);     // true

4.一 流程序调整制

流程序调控制主要有原则语句和循环语句。条件语句又分为:if语句,if-else语句,switch语句等。循环语句分为:while循环,for循环,do-while循环。

七、面向对象

前面提到过,JavaScript中具有的都以指标。在面向对象编制程序中,对象是类的实例,而类是全体同样属性和行事的一类对象的架空和汇集。例如:狮子对象是动物这1类型中的2个实例。面向对象编制程序有三大特点:封装,继承和多态。

相关文章