JavaScript之完整版学习包含ES6

这是一骗javascript的教程，包含ES6，读完一遍对你的帮助，绝对是巨大 的，大家加油

JavaScript 和 Java 的对比
JavaScript                                                                  
面向对象。不区分对象类型。通过原型机制继承，任何对象的属性和方法均可以被动态添加。   基于类系统。分为类和实例，通过类层级的定义实现继承。不能动态增加对象或类的属性或方法。
变量类型不需要提前声明(动态类型)。  
Java                                           
变量类型必须提前声明(静态类型)。
不能直接自动写入硬盘。                                                        可以直接自动写入硬盘。
第一步就是Hello
function greetMe(user){
  return "Hi " + user;
}
console.log(greetMe("steven"));//"Hi steven"

//javascript 是区分大小写的,使用Unicode字符集

//注释
//单行注释  //
//多行注释 /**/


//声明

var //声明一个变量，可选择将其初始化为一个值。
let //声明一个块作用域的局部变量(block scope local variable)，可选择将其初始化为一个值
const //声明一个只读的常量。

//变量

//在应用程序中，使用变量来作为值的符号名。变量的名字又叫做标识符，其需要遵守一定的规则。

//一个 JavaScript 标识符必须以字母、下划线（_）或者美元符号（$）开头；后续的字符也可以是数字（0-9）。因为 JavaScript 语言是区分大小写的，这里所指的字母可以是“A”到“Z”（大写的）和“a”到“z”（小写的）。
var a//undefined
let a//undefined
//通过undefined可以0判断出是否赋值
var input;
if(input === undefined){
  doThis();
}else{
  doThat();
}
//undefined 值在布尔类型环境中会被当作 false。例如，下面的代码将会执行函数 myFunction，因为数组myArray中的元素未被赋值：
var  myArray = [];
if(!imyArray[0]){
  myfunction();
}
//数值类型环境中 undefined 值会被转换为 NaN。
var a;
a+2//NAN
//当你对一个 null 变量求值时，空值 null 在数值类型环境中会被当作0来对待，而布尔类型环境中会被当作 false。
var n = null;
typeof(n);//object
n*32//0
变量的作用域

//在所有函数之外声明的变量，叫做全局变量，因为它可被当前文档中的任何其他代码所访问。在函数内部声明的变量，叫做局部变量，因为它只能在该函数内部访问。

//ECMAScript 6 之前的JavaScript没有 语句块 作用域；相反，语句块中声明的变量将成为语句块所在代码段的局部变量。例如，如下的代码将在控制台输出 5，因为 x 的作用域是声明了 x 的那个函数（或全局范围），而不是 if 语句块。
if(true){
  var x = 5
}
console.log(x) //5
//如果使用 ECMAScript 6 中的 let 声明，上述行为将发生变化。
if(true){
  let x = 5
}
console.log(x)//VM307:1 Uncaught ReferenceError: y is not defined
//变量声明提升(Variable hoisting)

//JavaScript 变量的另一特别之处是，你可以引用稍后声明的变量而不会引发异常。这一概念称为变量声明提升(hoisting)；JavaScript 变量感觉上是被“提升”或移到了所有函数和语句之前。然而提升后的变量将返回 undefined 值。所以在使用或引用某个变量之后进行声明和初始化操作，这个被提升的引用仍将得到 undefined 值。
console.log(x);
var x = 3;//undefined

//这个地方讲一下，你把下面那个var去掉就会明白怎么回事了
var myvar = "my value";
(function(){
  console.log(myvar);//undefined;
  var myvar = "local value"
})()
//let定义的就不会导致变量的提升
console.log(a);//ReferenceError
let a = 10

函数提升（Function hoisting）

//对于函数，只有函数声明会被提升到顶部，而不包括函数表达式。
foo();//"bar"
function foo(){
  console.log("bar");
}


foo()//TypeError: baz is not a function
var foo = function(){
  console.log("bar");
}
全局变量(Global variables)


常量(Constants)
//你可以用关键字 const 创建一个只读(read-only)的常量。常量标识符的命名规则和变量相同：必须以字母、下划线或美元符号开头并可以包含有字母、数字或下划线。
const prefix = "212"
在同一作用域中，不能使用与变量名或函数名相同的名字来命名常量。例如：
//this will cause an error
function  f(){
  const f = 5;
}
//this will cause an error also
function f(){
  const g = 5;
  var g;
}
//但是对象的属性是不受保护的，就像是python里面的元祖
e.g
const MY_OBJECT = {"key":"value"}
MY_OBJECT.key = 'otherValue';
数据结构和类型
数据类型
六种 原型 数据类型:
Boolean.  布尔值，true 和 false.
null. 一个表明 null 值的特殊关键字。 JavaScript 是大小写敏感的，因此 null 与 Null、NULL或其他变量完全不同。
undefined.  变量未定义时的属性。
Number.  表示数字，例如： 42 或者 3.14159。
String.  表示字符串，例如："Howdy"
Symbol ( 在 ECMAScript 6 中新添加的类型).。一种数据类型，它的实例是唯一且不可改变的。
以及 Object 对象

Objects 和 functions 是本语言的其他两个基本要素。你可以将对象视为存放值的命名容器，而将函数视为你的应用程序能够执行的过程(procedures)。
数据类型的转换(Data type conversion)
JavaScript是一种动态类型语言(dynamically typed language)。这意味着你声明变量时可以不必指定数据类型，而数据类型会在脚本执行时根据需要自动转换。因此，你可以这样来定义变量：
var answer = 42;
answer  = "this is very good...."
//因为 JavaScript 是动态类型的，这样赋值并不会提示出错。
在涉及加法运算符(+)的数字和字符串表达式中，JavaScript 会把数字值转换为字符串。例如，假设有如下的语句：
x = "The answer is" + 42//"The answer is 42"
y = 42 +"is the answer"//"42 is the answer"

在涉及其它运算符（译注：如下面的减号'-'）时，JavaScript语言不会把数字变为字符串。例如（译注：第一例是数学运算，第二例是字符串运算）：
"37"-7 //30
"37"+7 //"377"

字符串转换为数字(converting strings to numbers)

//有一些方法可以将内存中表示一个数字的字符串转换为对应的数字
parseInt()和parseFloat()
parseInt 仅能够返回整数，所以使用它会丢失小数部分。另外，调用 parseInt 时最好总是带上进制(radix) 参数，这个参数用于指定使用哪一种进制。
//单目加法运算符
将字符串转换为数字的另一种方法是使用单目加法运算符。
"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1")//2.2
字面量 (Literals)
（译注：字面量是由语法表达式定义的常量；或，通过由一定字词组成的语词表达式定义的常量）

在JavaScript中，你可以使用各种字面量。这些字面量是脚本中按字面意思给出的固定的值，而不是变量。（译注：字面量是常量，其值是固定的，而且在程序脚本运行中不可更改，比如false，3.1415，thisIsStringOfHelloworld ，invokedFunction: myFunction("myArgument")。本节将介绍以下类型的字面量：

数组字面量(Array literals)
布尔字面量(Boolean literals)
浮点数字面量(Floating-point literals)
整数(Intergers)
对象字面量(Object literals)
RegExp literals
字符串字面量(String literals)
//数组字面量 (Array literals)
数组字面值是一个封闭在方括号对([])中的包含有零个或多个表达式的列表，其中每个表达式代表数组的一个元素。当你使用数组字面值创建一个数组时，该数组将会以指定的值作为其元素进行初始化，而其长度被设定为元素的个数
e.g
var coffees = ["French Roast","Colombian","Kona"];
var a = [3];
console.log(a.length)//1
console.log(a[0]);//3
注意 这里的数组字面值也是一种对象初始化器
数组字面值中的多余逗号

你不必列举数组字面值中的所有元素。若你在同一行中连写两个逗号（,），数组中就会产生一个没有被指定的元素，其初始值是undefined。以下示例创建了一个名为fish的数组：

var fish = ["Lion", , "Angel"];
在这个数组中，有两个已被赋值的元素，和一个空元素（fish[0]是"Lion"，fish[1]是undefined，而fish[2]是"Angel"；译注：此时数组的长度属性fish.length是3)。
如果你在元素列表的尾部添加了一个逗号，它将会被忽略。在下面的例子中，数组的长度是3，并不存在myList[3]这个元素（译注：这是指数组的第4个元素噢，作者是在帮大家复习数组元素的排序命名方法）。元素列表中其它所有的逗号都表示一个新元素（的开始）。
注意：尾部的逗号在早期版本的浏览器中会产生错误，因而编程时的最佳实践方式就是移除它们。
//(译注：而“现代”的浏览器似乎鼓励这种方式，因为好多网页中都这么写？)
var myList = ['home','','school'];
//myList[0] = undefined;
//myList[1] = home;
//下面这个例子的length是4，最后一个逗号被忽略了
var myList = ['home', , 'school', , ];
理解多余的逗号（在脚本运行时会被如何处理）的含义，对于从语言层面理解JavaScript是十分重要的。但是，在你自己写代码时：显式地将缺失的元素声明为undefined，将大大提高你的代码的清晰度和可维护性。

布尔字面量 (Boolean literals)

（译注：即逻辑字面量）

布尔类型有两种字面量：true和false。

不要混淆作为布尔对象的真和假与布尔类型的原始值true和false。布尔对象是原始布尔数据类型的一个包装器。参见 布尔对象。

整数 (Intergers)

（译注：原文如此，没写成“整数字面量”，这里指的是整数字面量。）

整数可以用十进制（基数为10）、十六进制（基数为16）、八进制（基数为8）以及二进制（基数为2）表示。

十进制整数字面量由一串数字序列组成，且没有前缀0。
八进制的整数以 0（或0O、0o）开头，只能包括数字0-7。
十六进制整数以0x（或0X）开头，可以包含数字（0-9）和字母 a~f 或 A~F。
二进制整数以0b（或0B）开头，只能包含数字0和1。
严格模式下，八进制整数字面量必须以0o或0O开头，而不能以0开头。

整数字面量举例：

0, 117 and -345 (十进制, 基数为10)
015, 0001 and -0o77 (八进制, 基数为8)
0x1123, 0x00111 and -0xF1A7 (十六进制, 基数为16或"hex")
0b11, 0b0011 and -0b11 (二进制, 基数为2)

浮点数字面量 (Floating-point literals)

浮点数字面值可以有以下的组成部分：

一个十进制整数，可以带正负号（即前缀“+”或“ - ”），
小数点（“.”），
小数部分（由一串十进制数表示），
指数部分。
指数部分以“e”或“E”开头，后面跟着一个整数，可以有正负号（即前缀“+”或“-”）。浮点数字面量至少有一位数字，而且必须带小数点或者“e”（大写“E”也可）。

简言之，其语法是：

[(+|-)][digits][.digits][(E|e)[(+|-)]digits]
例如：

3.14
-.2345789 // -0.23456789
-3.12e+12  // -3.12*1012
.1e-23    // 0.1*10-23=10-24=1e-24

对象字面量 (Object literals)

对象字面值是封闭在花括号对({})中的一个对象的零个或多个"属性名-值"对的（元素）列表。你不能在一条语句的开头就使用对象字面值，这将导致错误或产生超出预料的行为， 因为此时左花括号（{）会被认为是一个语句块的起始符号。（译者：这 里需要对语句statement、块block等基本名词的解释）

以下是一个对象字面值的例子。对象car的第一个元素（译注：即一个属性/值对）定义了属性myCar；第二个元素，属性getCar，引用了一个函数（即CarTypes("Honda")）；第三个元素，属性special，使用了一个已有的变量（即Sales）。
var Sales = "Toyota";
function CarTypes(name){
  return (name === "Honda")?
  name:
  "Sorry,we don't sell" + name +".";
var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };
console.log(car.myCar);   // Saturn
console.log(car.getCar);  // Honda
console.log(car.special); // Toyota
//下面是更进一步
var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };

console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda

//对象属性名字可以是任意字符串，包括空串。如果对象属性名字不是合法的javascript标识符，它必须用""包裹。属性的名字不合法，那么便不能用.访问属性值，而是通过类数组标记("[]")访问和赋值。

var unusualPropertyNames = {
  "": "An empty string",
  "!": "Bang!"
}
console.log(unusualPropertyNames."");   // 语法错误: Unexpected string
console.log(unusualPropertyNames[""]);  // An empty string
console.log(unusualPropertyNames.!);    // 语法错误: Unexpected token !
console.log(unusualPropertyNames["!"]); // Bang!

//下面这个请注意
var foo = {a: "alpha", 2: "two"};
console.log(foo.a);    // alpha
console.log(foo[2]);   // two
//console.log(foo.2);  // Error: missing ) after argument list
//console.log(foo[a]); // Error: a is not defined
console.log(foo["a"]); // alpha
console.log(foo["2"]); // two


在ES2015，对象字面值扩展支持在创建时设置原型，简写foo：foo分配，定义方法，加工父函数（super calls），计算属性名(动态)。总之，这些也带来了对象字面值和类声明紧密联系起来，让基于对象的设计得益于一些同样的便利。
var obj = {
  //__proto__
  __proto__:theProtoObj,
  //处理程序：处理程序的缩写
  handler,
  //方法
  toString(){
    //super calls
    return "d " + super.toString();
  },
  //Computer (dynamic) property names
  ['prop_'+(() =>42)()]:42
};
//上面的这段函数你可能现在还看不懂,不过不用急,马上就懂了

RegExp 字面值
一个正则表达式是字符被斜线（译注：正斜杠“/”）围成的表达式。下面是一个正则表达式文字的一个例子。
var re = /ab+c/;
字符串字面量 (String literals)

//字符串字面量是由双引号（"）对或单引号（'')括起来的零个或多个字符。字符串被限定在同种引号之间；也即，必须是成对单引号或成对双引号。下面的例子都是字符串字面值：

"foo"
'bar'
"1234"
"one line \n another line"
"John's cat"
console.log("John's cat".length)
// 将打印字符串中的字符个数（包括空格）
// 结果为：10
在ES2015中，还提供了一种模板字符串（template literals），模板字符串提供了一些语法糖来帮你构造字符串。这与Perl、Python还有其他语言中的字符串插值（string interpolation）的特性非常相似。除此之外，你可以在通过模板字符串前添加一个tag来自定义模板字符串的解析过程，这可以用来防止注入攻击，或者用来建立基于字符串的高级数据抽象。
// 基础字符串的创建
`In JavaScript '\n' is a line-feed.`

// 多行的字符串
`In JavaScript this is
 not legal.`

// 字符串插值，这个实在是太酷了，省掉了拼接
var name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`

// 构建一个HTTP请求前缀
POST`http://foo.org/bar?a=${a}&b=${b}
     Content-Type: application/json
     X-Credentials: ${credentials}
     { "foo": ${foo},
       "bar": ${bar}}`(myOnReadyStateChangeHandler);
       在字符串中使用的特殊字符

       作为一般字符的扩展，你可以在字符串中使用特殊字符，如下例所示。

       "one line \n another line"
       以下表格列举了你能在JavaScript的字符串中使用的特殊字符。

       表 2.1 JavaScript 特殊字符
       字符   意思
       \0   Null字节
       \b   退格符
       \f   换页符
       \n   换行符
       \r   回车符
       \t   Tab (制表符)
       \v   垂直制表符
//       \' 单引号
//       \" 双引号
       \\   反斜杠字符（\）
       \XXX 由从0到377最多三位八进制数XXX表示的 Latin-1 字符。例如，\251是版权符号的八进制序列。
       \xXX 由从00和FF的两位十六进制数字XX表示的Latin-1字符。例如，\ xA9是版权符号的十六进制序列。
       \uXXXX   由四位十六进制数字XXXX表示的Unicode字符。例如，\ u00A9是版权符号的Unicode序列。见Unicode escape sequences (Unicode 转义字符).
       \u{XXXXX}    Unicode代码点 (code point) 转义字符。例如，\u{2F804} 相当于Unicode转义字符 \uD87E\uDC04的简写。
       译注：严格模式下，不能使用八进制转义字符。

       转义字符

//       对于那些未出现在表2.1中的字符，其所带的前导反斜线'\'将被忽略。但是，这一用法已被废弃，应当避免使用。

//       通过在引号前加上反斜线'\'，可以在字符串中插入引号，这就是引号转义。例如:

       var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
       console.log(quote);
       代码的运行结果为:

       He read "The Cremation of Sam McGee" by R.W. Service.
//       要在字符串中插入'\'字面值，必须转义反斜线。例如，要把文件路径 c:\temp 赋值给一个字符串，可以采用如下方式:

       var home = "c:\\temp";