-
Number（数字） -
String（字符串） -
Boolean（布尔） -
Symbol（符号）（ES2015 新增） -
Object（对象） -
null（空） -
undefined（未定义） -
Error（错误）
数字
// 遵循 IEEE 754 标准的双精度 64 位格式
0.1 + 0.2 = 0.30000000000000004
Math.sin(3.5);
var circumference = 2 * Math.PI * r;
parseInt("123", 10); // 123
parseInt("010", 10); // 10
parseInt("010"); // 8
parseInt("0x10"); // 16
parseInt("11", 2); // 3
+ "42"; // 42
+ "010"; // 10
+ "0x10"; // 16
parseInt("hello", 10); // NaN
NaN + 5; //NaN
isNaN(NaN); // true
1 / 0; // Infinity
-1 / 0; // -Infinity
isFinite(1/0); // false
isFinite(Infinity); // false
isFinite(-Infinity); // false
isFinite(NaN); // false
isFinite(0); // true
isFinite(2e64); // true
isFinite("0"); // true
// 如果是纯数值类型的检测，则返回 false：
Number.isFinite("0"); // false
/*
parseInt()和parseFloat()
函数会尝试逐个解析字符串中的字符，直到遇上一个无法被解析成数字的字符，
然后返回该字符前所有数字字符组成的数字。但是运算符 "+"对字符串的转换方
式与之不同， 只要字符串含有无法被解析成数字的字符，该字符串就将被转换成
`NaN`。可分别使用这两种方法解析“10.2abc”这一字符串，并比较得到的结果，
来理解这两种方法的区别。
*/
字符串
一串Unicode 字符(UTF-16编码单元)序列
"hello".length; // 5
"hello".charAt(0); // "h"
"hello, world".replace("world", "mars"); // "hello, mars"
"hello".toUpperCase(); // "HELLO"
其他类型
/*
JavaScript 中的 null表示一个空值（non-value），必须使用 null 关键字才能访问，
undefined是一个“undefined（未定义）”类型的对象，表示一个未初始化的值，也就是
还没有被分配的值。我们之后再具体讨论变量，但有一点可以先简单说明一下，JavaScript
允许声明变量但不对其赋值，一个未被赋值的变量就是 `undefined` 类型。还有一点需要
说明的是，`undefined` 实际上是一个不允许修改的常量。
*/
// false、0、空字符串（""）、NaN、null 和 undefined 被转换为 false
// 所有其他值被转换为 true
Boolean(''); // false
Boolean(234); // true
变量
声明一个新变量的关键字 let, const 和 var
- let 语句声明一个块级作用域的本地变量，并且可选的将其初始化为一个值。
let a;
let name = 'Simon';
// myLetVariable is *not* visible out here
for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
// myLetVariable is only visible in here
}
// myLetVariable is *not* visible out here
- const 允许声明一个不可变的常量。这个常量在定义域内总是可见的。
const Pi = 3.14; // 设置 Pi 的值
Pi = 1; // 将会抛出一个错误因为你改变了一个常量的值。
- var 是最常见的声明变量的关键。
如果声明了一个变量却没有对其赋值，那么这个变量的类型就是 undefined。
var a;
var name = "simon";
// myVarVariable *is* visible out here
for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
// myVarVariable is visible to the whole function
}
// myVarVariable *is* visible out here
运算符
x += 5; // 等价于 x = x + 5;
"hello" + " world"; // hello world
"3" + 4 + 5; // 345
3 + 4 + "5"; // 75
123 == "123" // true
1 == true; // true
1 === true; //false
123 === "123"; // false
控制结构
var name = "kittens";
if (name == "puppies") {
name += "!";
} else if (name == "kittens") {
name += "!!";
} else {
name = "!" + name;
}
name == "kittens!!"; // true
while (true) {
// 一个无限循环！
}
var input;
do {
input = get_input();
} while (inputIsNotValid(input))
for (var i = 0; i < 5; i++) {
// 将会执行五次
}
for (let value of array) {
// do something with value
}
for (let property in object) {
// do something with object property
}
var name = o && o.getName();
var name = cachedName || (cachedName = getName());
var allowed = (age > 18) ? "yes" : "no";
switch(action) {
case 'draw':
drawIt();
break;
case 'eat':
eatIt();
break;
default:
doNothing();
}
switch(a) {
case 1: // 继续向下
case 2:
eatIt();
break;
default:
doNothing();
}
switch(1 + 3){
case 2 + 2:
yay();
break;
default:
neverhappens();
}
对象
JavaScript 中的对象，Object，可以简单理解成“名称-值”对
这样的数据结构设计合理，能应付各类复杂需求，所以被各类编程语言广泛采用。正因为 JavaScript 中的一切（除了核心类型，core object）都是对象，所以 JavaScript 程序必然与大量的散列表查找操作有着千丝万缕的联系，而散列表擅长的正是高速查找。
var obj = new Object();
var obj = {};
var obj = {
name: "Carrot",
"for": "Max",//'for' 是保留字之一，使用'_for'代替
details: {
color: "orange",
size: 12
}
}
obj.details.color; // orange
obj["details"]["size"]; // 12
function Person(name, age) {
this.name = name;
this.age = age;
}
// 定义一个对象
var You = new Person("You", 24);
// 我们创建了一个新的 Person，名称是 "You"
// ("You" 是第一个参数, 24 是第二个参数..)
obj.name = "Simon"
var name = obj.name;
// bracket notation
obj['name'] = 'Simon';
var name = obj['name'];
// can use a variable to define a key
var user = prompt('what is your key?')
obj[user] = prompt('what is its value?')
obj.for = "Simon"; // 语法错误，因为 for 是一个预留关键字
obj["for"] = "Simon"; // 工作正常
数组
var a = new Array();
a[0] = "dog";
a[1] = "cat";
a[2] = "hen";
a.length; // 3
var a = ["dog", "cat", "hen"];
a.length; // 3
var a = ["dog", "cat", "hen"];
a[100] = "fox";
a.length; // 101
typeof(a[90]); // undefined
for (var i = 0; i < a.length; i++) {
// Do something with a[i]
}
for (const currentValue of a) {
// Do something with currentValue
}
// i是索引非元素
for (var i in a) {
// Do something with a[i]
}
["dog", "cat", "hen"].forEach(function(currentValue, index, array) {
// Do something with currentValue or array[index]
});
a.push(item);
a.toString() 返回一个包含数组中所有元素的字符串，每个元素通过逗号分隔。
a.toLocaleString() 根据宿主环境的区域设置，返回一个包含数组中所有元素的字符串，每个元素通过逗号分隔。
a.concat(item1[, item2[, ...[, itemN]]]) 返回一个数组，这个数组包含原先 a 和 item1、item2、……、itemN 中的所有元素。
a.join(sep) 返回一个包含数组中所有元素的字符串，每个元素通过指定的 sep 分隔。
a.pop() 删除并返回数组中的最后一个元素。
a.push(item1, ..., itemN) 将 item1、item2、……、itemN 追加至数组 a。
a.reverse() 数组逆序（会更改原数组 a）。
a.shift() 删除并返回数组中第一个元素。
a.slice(start, end) 返回子数组，以 a[start] 开头，以 a[end] 前一个元素结尾。
a.sort([cmpfn])
依据可选的比较函数 cmpfn 进行排序，如果未指定比较函数，则按字符顺序比较（即使被比较元素是数字）。
a.splice(start, delcount[, item1[, ...[, itemN]]])
从 start 开始，删除 delcount 个元素，然后插入所有的 item。
a.unshift(item1[, item2[, ...[, itemN]]])
将 item 插入数组头部，返回数组新长度（考虑 undefined）。
函数
function add(x, y) {
var total = x + y;
return total;
}
function add() {
var sum = 0;
for (var i = 0, j = arguments.length; i < j; i++) {
sum += arguments[i];
}
return sum;
}
add(2, 3, 4, 5); // 14
function avg(...args) {
var sum = 0;
for (let value of args) {
sum += value;
}
return sum / args.length;
}
avg(2, 3, 4, 5); // 3.5
// 匿名函数
var avg = function() {
var sum = 0;
for (var i = 0, j = arguments.length; i < j; i++) {
sum += arguments[i];
}
return sum / arguments.length;
};
var a = 1;
var b = 2;
(function() {
var b = 3;
a += b;
})();
a; // 4
b; // 2
// 递归
function countChars(elm) {
if (elm.nodeType == 3) { // TEXT_NODE 文本节点
return elm.nodeValue.length;
}
var count = 0;
for (var i = 0, child; child = elm.childNodes[i]; i++) {
count += countChars(child);
}
return count;
}
var charsInBody = (function counter(elm) {
if (elm.nodeType == 3) { // 文本节点
return elm.nodeValue.length;
}
var count = 0;
for (var i = 0, child; child = elm.childNodes[i]; i++) {
count += counter(child);
}
return count;
})(document.body);
JavaScript 允许你通过任意函数对象的 apply() 方法来传递给它一个数组作为参数列表。
avg.apply(null, [2, 3, 4, 5]); // 3.5
自定义对象
function makePerson(first, last) {
return {
first: first,
last: last,
fullName: function() {
return this.first + ' ' + this.last;
},
fullNameReversed: function() {
return this.last + ', ' + this.first;
}
}
}
s = makePerson("Simon", "Willison");
s.fullName(); // Simon Willison
s.fullNameReversed(); // Willison, Simon
// this的作用域
// 当我们调用 fullName() 时，this 实际上是指向全局对象的，
// 并没有名为 first 或 last 的全局变量，所以它们两个的返回值都会是 undefined。
s = makePerson("Simon", "Willison");
var fullName = s.fullName;
fullName(); // undefined undefined
function Person(first, last) {
this.first = first;
this.last = last;
}
Person.prototype.fullName = function() {
return this.first + ' ' + this.last;
}
Person.prototype.fullNameReversed = function() {
return this.last + ', ' + this.first;
}
s = new Person("Simon", "Willison");
s.firstNameCaps(); // TypeError on line 1: s.firstNameCaps is not a function
Person.prototype.firstNameCaps = function() {
return this.first.toUpperCase()
}
s.firstNameCaps(); // SIMON
var s = "Simon";
s.reversed(); // TypeError on line 1: s.reversed is not a function
String.prototype.reversed = function() {
var r = "";
for (var i = this.length - 1; i >= 0; i--) {
r += this[i];
}
return r;
}
s.reversed(); // nomiS
"This can now be reversed".reversed(); // desrever eb won nac sihT
var s = new Person("Simon", "Willison");
s; // [object Object]
Person.prototype.toString = function() {
return '<Person: ' + this.fullName() + '>';
}
s.toString(); // <Person: Simon Willison>
内部函数
function parentFunc() {
var a = 1;
function nestedFunc() {
var b = 4; // parentFunc 无法访问 b
return a + b;
}
return nestedFunc(); // 5
}
闭包
function makeAdder(a) {
return function(b) {
return a + b;
}
}
var add5 = makeAdder(5);
var add20 = makeAdder(20);
add5(6); // 11
add20(7); // 27
网友评论