哲学原理《Faded》音评

by admin on 2018年11月19日
4.2.3 逻辑运算符

(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,则归第一个操作数,否则回第二单操作数。在boolean环境面临应用时,两只操作数结果尚且为true时,返回true,否则回false。
  • 可知转移为false的值有,0,””,null,undefined。

死操作:
以实行逻辑和操作时,当第一只操作数的结果为false时,就无以执行第二个操作数的求值了。因为无第二单操作数为何值,其结果都非容许也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)逻辑非(!)
任凭操作数是啊品种的数码,该操作都见面回一个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。

设若灯塔,照亮了我的路程;如星星之火,为自家之社会风气增添暖色的坏人,你的产出而烟花般灿烂,亦要流星转瞬即没有。你能放得到我之呼唤么?听的到么?

7.1 构造函数

眼前提到过,使用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关键字指向了,当前只要创的对象。

Were are you now? Were you onlyimaginary?

4.2.4 位运算符

位运算是比较低层次的运算,按内存中表示数值的位来操作数值。JavaScript中有所的数值都是因64号格式存储,而各类操作符是先期以64各项之价值转换成32各的整数,然后实施操作,最后重复将结果转换回64员。

于有号的平头,32受的面前31各项表示整数的值,第32位表示数值的记,用0表示整数,1象征负数,因此第32位也叫符号位。其中,正数是坐老二迈入制格式存储的,负数二进制补码的样式储存的。

(1)原码、反码和补码
原码,是该数值的符位以及绝对值的二进制表示。例如:

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

反码,正数的反码是彼原码。负数的反码,是符号位不更换,其余各位取反,即1变成0,0变成1。例如:

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不时,结果吗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时时,结果也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)按位异或(^)
随位异或,是拿少个操作数的二进制位对一起,当半单数值的各项中只有发生一个为1时不时,结果为1,两独还也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

盖《Loseyourself》中之同一句英文来总结:You can do anything youup your
mind to,man.

3.4 Object

对象是JavaScript中至关重要的数据类型,除数字、true、false、null、undefined和字符串外,所有的价值都是目标。在JavaScript中目标是千篇一律组无序的键值对聚集,类似其他语言的HashMap、Dictionary等数据结构。下面会生出单独一微节来专门讲述生对象。

卿是我命之同一道光影,你会 感觉到我们啊?

6.1 函数的定义

以JavaScript中,函数的概念来如下几种植实现方式:
(1)function关键字+函数名+参数列表+花括号做的语句块,例如:

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

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

(2)使用Function构造函数。一般,不引进这种使用方式。

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

您本套于何处?

6.2 函数的参数和里属性

JavaScript中函数定义尚无点名函数参数的项目,调用时为无对实参的价值做项目检查,同样也未反省参数单数。

I’m letting go, a deeper dive.

7.2.2 访问属性规则
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);            // 小赵

当访问对象的某属性时,会根据加的特性名称来寻觅。如果,在拖欠目标的实例中找到该属性,则赶回属性之值;否则,则继续找该对象的原型对象,在原型对象被觅该属性,依次稀有提高搜索,直到搜索到原型链的终极。因此,对象的属于性会覆盖同名的拖欠目标的原型对象的同名属性。

了解的灯光,却都暗失色;而你点了自之气。

4.2 运算符

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

  • 算术运算符:+-*/%++--+=-=*=/=%=等。
  • 论及运算符:<><=>======!=!==
  • 逻辑运算符:&&||!
  • 位运算符:~&|^<<>>>>>
  • 任何操作符:=,?=

you were the shadow to mylife,did u feelus

1.1 JavaScript概述

率先,JavaScript是均等宗动态类型的编程语言。支持面向对象、函数式等编程范式。同时,它吗是运作于宿主环境下之轻量级的脚本语言,例如:浏览器,JavaScript代码可放置至HTML页面中。当然,也时有发生使用基于Node.js的服务器环境。可以说她是主流浏览器还支持的脚本语言,这吗塑造了JavaScript在PC、手机、平板等条件处理以及网页交互时的天然优势。随着HTML5的拓宽以及广泛应用,出现了大气基于JavaScript的跨平台框架和游戏引擎,是通往全栈开发大值得学习的同样流派编程语言。正使以编程语言界流行在“世界自然是JS的”的槽点,足以可见JavaScript的强硬。

The monsters running wild inside of me, I’mfaded

6.3 函数的特性

前提到过,每个函数都是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:形参的个数。

Where are you now?Where are younow?Where are younow?

4.1.1 条件语句

(1)if语句

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

欠组织,当极1(condition1为true)满足时,执行语句1(statement1),否则极2(condition2为true)满足时,执行语句2,以上还无饱则实行语句3(statement3)。

这里的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结构类似,也是同一种植常见采用的流程控制语句。

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

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

表达式(expression)可以采用其他数据类型,包括字符串、对象。case的价(value)也可是变量、表达式,不必然是常量。这点及另组成部分言语不同,只能采取数值。

Atlantis,under thesea亚特兰蒂斯,没为海洋

4.1.2 循环语句子

(1)while语句
while循环包含循环条件及循环体,当循环条件满足条件时,才见面实行循环体内之代码块。

while(expression) {
    statement;
}

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

(2)for语句
for语词一般含初始标准、循环条件、循环递增(递减)语句三部分。

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教程

徒是顺其自然,深藏海底

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}];

(2)数组元素的访问。

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中数组不在数组越界的问题。

(3)数组元素的增长与删除
补充加元素:

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' ]

(6)数组的遍历与迭代

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方法会对数组中之诸一样起运行给定的函数,并回该函数会回去吗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方法一致会对数组中列一样起运行给定的函数。该措施无回值。

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方法会将每次运行给定的函数返回的价值,组成一个初的数组。

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

console.log(t1);        // true

流淌:map方法同样会对数组中的各级一样项都运作给定的函数,如果该函数的无论一码结果吧true,则赶回true。

(7)其它
自,数组还有一些另的用法及函数。这里就不一一介绍了。感兴趣的,可以参考文末列举的参阅链接。

Where are you now? Where are younow?

3.2 String

(1)String类型字符串是由于单引号或对引号包括的零个或多只字符序列。

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

(2)字符串可以像数组一样看,但若是字符串的价值确定了,就未克更改。

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文档。

乃本套在哪里?

3.1 Number

(1)JavaScript中连无区分整型或浮点数,所有数字都统一用64各项浮点数表示。可用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不会见。

认清一个变量是否是不数值,可以以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

判断一个变量是否是发穷数,可以动用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

Another start, you fadeaway,you fadeaway

6.2.1 函数的参数
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,多之参数将吃废弃。

These shallow waters never met,what Ineeded?

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。

今天你身于何处?另一个期望

2、基本概念

若现在身在哪里?难道仅仅存留于己之想像中?

3.6 null

同undefined类似,null类型也就来一个值null。空值null表示一个空的对象指针。

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

Where are you now? Anotherdream

3.7 typeof、instanceof与Object.prototype.toString

由于JavaScript是动态类型的,因此即便需一致种手段来检测给定的变量的有血有肉数据类型。

(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

(2)instanceof:下文会讨论。
(3)Object.prototype.toString:下文会讨论。

此间迎来音乐的率先独高潮,接连三句之“where are you
now”提出质问,难道“你”从未起了?难道这周还只是是自的幻想?

2.5 语句

JavaScript中各条告句子都是盖分行结尾,但分号不是必需的。但建议是绝不简单分号,来避免使无整的输入等问题。语句块用花括号包含。

故迷失,疲惫不堪

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来判断。

Where are you now?Where are younow?你现在套于何方?

5.1 对象的创始

对象的创建分为两种艺术:
(1)使用new操作符,后面紧跟构造函数

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

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

var student = {
    name : "AlphaGL",
    age  : 18
    print: function () {
        console.log("hello AlphaGL");
    },
};

时刻之图在于虚化,虚化背影,模糊事实。很多篆刻当记忆力里走马观花似的光景,都当报告自己,那个人,曾经以本人之人命遭受冒出过,只是无法确定,是于梦中要实际。她的同皱眉一乐,看似近在咫尺,却同时处于海外,让自家怀念要守,却以束手无策凑。

5.2 读取属性

可以通过点(.)或者中括号([])的办法获得对象属性之价值。

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

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

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

(2)通过中括号访问属性之价,中括号内可以是变量且计量结果要是字符串的表达式。如果属于性名包含回导致语法错误的字符,或者属于性名使用的凡重要字或保留字,也得以应用中括号表示。

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

诚如推荐使用点的法子去赢得对象属性。

只有出下定狠心,什么都没法儿阻挡你!

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

亚特兰蒂斯:一个风传着具有高度文明的古大陆,最早出现让古希腊哲学家柏拉图的著作《对话录》里,据称在公元前一万几近年前于史前大洪水毁灭,沉没在大西洋面临;圣经《创世纪》中所描述的“伊甸园”指的虽是亚特兰蒂斯。

7.2.1 原型的动
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

Afraid our aim is out ofsight,wanna seeus,alive

2.6 变量

得采取var要字来定义变量,JavaScript的变量可以为此来保存任何类型的数码。例如:

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

啊堪运用逗号来定义多只变量。例如:

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

虽说JavaScript支持这种写法,一般不推荐。不仅可读性差,而且好出错。

当函数内声明的变量,那么该变量的作用域为该函数内。例如:

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

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

虽可去丢var声明来解决是题材,例如:

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

test();
console.log(name);

此刻,name就改为了全局变量。一般不推荐这种做法。全局变量难以维护,而且便于造成结构混乱。

The monster’s running wild inside ofme

2.2 标识符

此处的标识符,统指变量名、函数称为、属性名以及函数参数的名。那么,标识符的命名有以下规则:(这些规则跟C、Java等语言类)

  • 率先只字符必须是一个字母、下划线_或美元符号$
  • 其余字符则可以是字母、数字、下划线和美元符号。
  • 勿可知采用主要字、保留字来定义标识符。例如:if、for等。

横流:在JavaScript中,变量名、函数誉为甚至操作符等是分别轻重缓急写的。即name和Name代表的凡鲜单例外的变量。

Under the bright, but faded lights. You’ve set myheart on fire.

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。

So lost, I’m so lost.

4.1 流程控制

流程控制重点发生格语句和循环语句。条件语句以分为:if语句,if-else语句,switch语句等。循环语句子分为:while循环,for循环,do-while循环。

                              ——解释一•致毁灭之儒雅

JavaScript学习(1)之JavaScript基础

是因为工作因,开发语言逐渐以JavaScript为主,所以,抽空学习了下JavaScript语法。等时的办事稳定性之后,陆续会享用下自己于求学和付出过程被的有的经验总结。本着”技多不压身”的尺度和针对性各种编程语言的热衷,虽然笔者一直从游戏支付工作,也欣然而还要迈进的加入了JavaScript阵营。

PS:”整篇歌唱听起来有种植迷失在天体中心的孤寂感,fade有“褪色,凋零以及逐渐消除”之了,有人拿其翻译成“人间迷走”。歌中之“你”或许真存在,是异常生命受到约略纵即没有的伊人,也恐怕是支持而一起挪来的迷信,对冀之苦苦追求直至疲惫不堪,或是对好和恨的难释怀。但结尾还如fade中那段熟悉激昂的副歌一样:我都不顾一切的追过,我抱有了,我找找了~无悔!”

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

那些镜花水月,从未目及,却这么渴望。

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。


7.2 原型与持续

每个对象还生一个私房属性(prototype)原型,该属性指为该目标的原型对象。可以清楚也任何编程语言中之,指向基类或者父类的意图。当然,该原型对象同发出一个协调之prototype,层层提高直到该目标的原型为null。null没有原型。JavaScript中几乎拥有的靶子都是位于原型链顶端的Object的实例,同样好解为,都是Object的子类。因此,使用原型对象可以让具有目标实例共享它所蕴藏的性与章程。

约就即是宿命吧,丢不了,也逃不丢。依然感谢您以自我生遭受留的足迹,黑暗里而向自己伸出手,使劲拉自同样拿,把自身带入光明。未曾放弃寻找,因为您尽管是自我之单。

2.4 严格模式

启用严格模式,会针对一些非确定的行为还是无安全之操作抛来错误。在剧本的顶部添加如下字符串:

"use strict";

为足以添加到函数内部,来指定该函数在严格模式下实施。

首句子说“you are the shadow to mylife”说明“你”曾经模糊或浅之面世,而“did
you feelus,another start, you
fadeaway”表明“你”已走远,消失在我们的视野里。紧接着的“alive”再次发表要“你”与我们且能够坚持到那么同样龙,希望更与“你”相见的愿景。

5.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

Were it all in myfantasy?难道就总体都只是自己的空想?

2.3 注释

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

// 这是一个单行注释

基本上执行注释使用/***/结构。例如:

/*
 * 这是一个多行注释
 */

哲学原理 1

3、数据类型

JavaScript中数据类型主要有:Number、String、Boolean、Object、undefined、null这几乎种植类型。以及关系到路判断时会因此到之操作有:typeof、instanceof、Object.prototype.toString。

如若今天有一个空子,一个空子,可以兑现就的冀望,你是不是能抓住机会还是无该溜走?你是不是能够结束于而的紧张狼狈,无视旁人起哄嘲笑,将眼光专注让您想只要到的地方?既然有就不克被她溜走,请牢记心脏也梦想律动的鸣响,因为那以是你提高的勃勃动力。

6、函数

函数,简单描述就是是可再调用多次的功能模块。在JavaScript中,每个函数都是Function类型的实例,因此也一律有属性和方。函数名为也是目标,可以管函数当作值来采取,这样虽提供巨大的八面玲珑。

Where are you now? Another dream你本身在哪儿?又平等街梦境

1.2 JavaScript应用范围

web前端:最近较火的Vue.js、React、 Angular等等前端框架层出不穷。
手机app:React
Native、PhoneGap、Weex等跨平台活动框架等,以及微信小序等。
玩引擎:Cocos2d-js、Unity、egret等引擎都支持JavaScript脚本语言。
服务器:pomelo、Node.js等。

兴许我们的靶子迷失在视野,只望我们都能够,幸存下来

4.2.2 关系运算符

之所以来判定一个操作数是否超越或低于或等另外一个操作数。

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值。
  • 设生一个操作数是NaN,则实行结果也false,执行不等于操作时,执行结果吧true。
  • null和undefined相等。但切莫能够将null和undefined转化为其他任何价值。
  • 如果生一个操作数是目标,另外一个操作数不是,则会调用对象的valueOf方法得到原始值,再下方面的平整。
  • 当半只操作数的值相同,类型也一律,并且都不是NaN时,则鲜只操作数全齐(===)。当于的一定量个操作数转换为平类别后的值等,则鲜只操作数相等(==)。

首先单高潮的最终引出“亚特兰蒂斯”这个地名,我急于从一个或者没在的已给洪水淹没的古国中搜寻寻“你”的身影,却恳请而不可,最终面黄肌瘦不堪。

6.2.2 函数的其中属性

当函数内部,有个与众不同之目标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

                                       ——解释三•致遗失的信

4.2.5 其它运算符

(1)赋值运算符(=)
赋值可以同其他运算符组合使用。例如:

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

(2)逗号运算符(,)
逗号运算符,可以再同漫长告词被履行多个操作。如果,逗号运算符用于赋值,则回表达式中之结尾一起。

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

《Faded》是挪威电音天才AlanWalker的成名作,它在原曲《Fade》上重复混音加入钢琴伴奏和天籁空灵般的女声,给本来空洞的舞曲富有质感。MV讲述了一个坐背包的后生以在相同张像寻找自己之家中的故事。他走遍了遥远,最终于照的引导下终于找到老人的房子,但意识房子已沦为废墟。在视频的终极,男主角拉下面具,绝望地面对这无情的真情。

7、面向对象

眼前提到过,JavaScript中具有的且是目标。在面向对象编程中,对象是接近的实例,而接近是具备同等属性和表现的一样近乎对象的悬空和集聚。例如:狮子对象是动物就无异于路中之一个实例。面向对象编程有三挺特征:封装,继承与多态。

狂野的猛兽驰骋在我心深处,我疲惫不堪

1、JavaScript概述以使用范围

                            ¬¬——解释二•致错过的爱侣

4.2.1 算术运算符

(1)加法操作符(+)
加以减法操作符时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。如果一个操作数是数值,另外一个操作数是-Infinity,则加法结果吗-Infinity。如果是Infinity加-Infinity,则加法结果吧NaN。如果一个操作数是数值,另外一个操作数是NaN,则加法结果也NaN。
  • 一经一个操作数是数值,另外一个操作数是boolean,null类型,则先将boolean和null类型转行成原始值,再实行加法运算。
  • 如若一个操作数是数值,另外一个操作数是目标,则会预先调用对象的valueOf方转化成原始值,如果目标没valueOf方法,则调用toString方法。

(2)减法运算符(-)
减法的运算规则和加法类似,这里就不再详细介绍了。

(3)乘法运算符(*)

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。
  • 一经一个非0数值与Infinity或-Infinity相乘,则结果吗Infinity或-Infinity,符号取决于操作数的符和Infinity还是-Infinity。0暨Infinity或-Infinity,则结果也NaN。
  • 设若一个操作数是数值,另外一个操作数是boolean或者字符串,则优先将拖欠操作数转化为原始值,如果转会后的价值不是数值,则结果吧NaN,否则执行例行乘法运算。
  • 若是一个操作数是数值,另外一个操作数是目标,则结果为NaN。如果是Date对象,则趁机以基于当前及1970年1月1日起的毫米数。

(4)除法操作数(/)
除法的演算规则及乘法类似,同样,这里就是不再详细介绍了。

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

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

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

综上,模运算规则如下:

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

(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 ]

狂野的怪兽驰骋在我心深处

4、流程控制以及运算符

5、对象

当介绍数据类型的上关系过,在JavaScript中目标是均等组无序的键值对聚集,类似其他语言的HashMap、Dictionary等数据结构。除数字、true、false、null、undefined和字符串外,所有的价值都是目标。JavaScript内置了Object、Date、Array、Function、RegExp等对象。所有目标就承Object对象。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图