Adakah es6 satu rangka kerja?

es6 bukan rangka kerja, tetapi standard bahasa JavaScript. es6 ialah versi ke-6 ECMAScript, bahasa pengaturcaraan skrip yang diseragamkan oleh Ecma International (sistem keahlian antarabangsa untuk organisasi piawaian maklumat dan telekomunikasi) melalui ECMA-262 ia adalah teras bahasa skrip JavaScript, menyediakan sintaks dan sintaks bahasa.

Persekitaran pengendalian tutorial ini: sistem Windows 7, ECMAScript versi 6, komputer Dell G3.

es6 bukan rangka kerja, tetapi standard bahasa JavaScript.

Nama penuh es6 ialah ECMAScript6 (versi ke-6 ECMAScript) Ia adalah standard untuk bahasa JavaScript yang dikeluarkan secara rasmi pada Jun 2015. Ia secara rasmi dipanggil ECMAScript 2015. (ES2015). Matlamatnya adalah untuk membolehkan bahasa JavaScript digunakan untuk menulis aplikasi berskala besar yang kompleks dan menjadi bahasa pembangunan peringkat perusahaan.

Dan ECMAScript ialah bahasa pengaturcaraan skrip yang diseragamkan oleh Ecma International melalui ECMA-262. Bahasa ini digunakan secara meluas di World Wide Web Ia sering dipanggil JavaScript atau JScript, jadi ia boleh difahami sebagai standard JavaScript, tetapi sebenarnya dua yang terakhir adalah pelaksanaan dan sambungan standard ECMA-262.

Hubungan antara JavaScript dan ECMAScript

Kadang-kadang orang menganggap JavaScript dan ECMAScript sebagai sama, tetapi JavaScript tidak mengandungi lebih banyak kandungan daripada ECMA-262 lebih banyak peruntukan dalam , JavaScript lengkap terdiri daripada tiga bahagian berikut:

• Teras (ECMAScript): Menyediakan sintaks dan objek asas bahasa; >

  Model Objek Dokumen (DOM): Menyediakan kaedah dan antara muka untuk memproses kandungan web;

• ECMAScript ialah teras JavaScript, menerangkan sintaks asas bahasa (var, untuk, jika, tatasusunan, dll.) dan jenis data (nombor, rentetan, Boolean, fungsi, objects ( obj, [], {}), null, undefined), ECMAScript ialah satu set piawaian yang mentakrifkan rupa bahasa (seperti JS).
• ECMAScript ditakrifkan oleh ECMA-262 ECMAScript ialah spesifikasi bahasa skrip standard yang diiktiraf di peringkat antarabangsa yang tidak bergantung pada pelayar web. Piawaian ECMA-262 terutamanya menetapkan bahawa bahasa ini terdiri daripada komponen berikut:

Syntax

Pembolehubah dan jenis data

• Kata kunci dan perkataan terpelihara

• Pengendali

• Pernyataan kawalan

• Object

• ECMAScript 6 pada asasnya telah menjadi standard industri Kepopularannya jauh lebih pantas daripada ES5 Sebab utamanya ialah pelayar moden menyokong ES6 dengan cepat, terutamanya Chrome dan Firefox kebanyakan ciri dalam ES6. [Pembelajaran yang disyorkan:
Tutorial JavaScript Lanjutan
• ]

Mengapa anda perlu belajar ES6? Untuk apa ES6 digunakan?

ES5 tidak dapat memenuhi keadaan hadapan yang semakin kompleks dan besar, dan boleh dikatakan ketinggalan zaman ES6 ialah peningkatan dan peningkatan kepada ES5.

1. Penyemak imbas arus perdana telah menyokong sepenuhnya ES6

2 Rangka kerja bahagian hadapan yang lebih baharu dalam industri telah menggunakan sintaks ES6 sepenuhnya

3. dan lain-lain semuanya berdasarkan sintaks ES6

4. Bermula dari pekerjaan, syarikat kecil dan sederhana, tindanan penuh, satu lagi kemahiran pada resume, dan tempoh percubaan juga boleh membantu anda bermula dengan lebih cepat.

Pembolehubah

biar Hanya satu pembolehubah let boleh diisytiharkan dalam skop Jika the child Jika pembolehubah let turut diisytiharkan dalam skop, ia tidak akan menjejaskan pembolehubah let dalam skop induk.

var
• Berbilang pembolehubah var boleh diisytiharkan dalam satu skop Jika pembolehubah var turut diisytiharkan dalam skop anak, ia juga akan mempengaruhi pembolehubah var dalam skop induk.
  
const
• Malar, bersamaan dengan muktamad, tidak boleh diubah suai.
  
global
• Pembolehubah yang tidak mengisytiharkan jenis pembolehubah lalai kepada pembolehubah global (atribut tetingkap).
  
• Berorientasikan objek
  

Prinsip Ciri berorientasikan objek JavaScript adalah berdasarkan prototaip dan pembina, yang berbeza daripada yang berasaskan kelas biasa. JavaScript tidak menyediakan ciri peringkat bahasa bagi warisan objek, tetapi melakukannya melalui penyalinan prototaip.

Tiga cara untuk mencipta objek
• 
  
• prototaip

  1. {pojo}（实例变量、实例方法、get、set） 
  2. function（实例变量、实例方法、prototype、apply、call） 
  3. class（实例变量、实例方法、prototype、extends、super）

Hanya fungsi , kelas mempunyai prototaip, maksudnya ialah menambah pembolehubah contoh dan kaedah contoh secara dinamik dan melaksanakan pewarisan.

Warisi

• call/apply
  应用在继承关系中，子类向父类传参时应用此关键字
• extends
  继承关系中使用，A extends B，则A是B的父类
• super
  在子类中调用父类的方法时应用次关键字
• ES5继承方式
  接下来我们手写一套组合继承（原型链继承（继承原型） + 构造继承（继承属性））。这种方式即可避免原型链继承中无法实现多继承，创建子类实例时，无法向父类构造函数传参的弊端，也可避免构造继承中不能继承原型属性/方法的弊端。

function Person(name,age){                                             /* 父类 */
    this.name = name || 'father';                            //实例变量
    this.namesonF = this.nameson;
    this.age = age;
    this.talk = function(){alert("talk");};                 //实例方法
};
function Son(name){                                                     /* 子类 */
    this.nameson = name || 'son';
    // Person.call(this,'name',18);                          //继承：构造继承，复制父类的实例属性给子类，不能继承原型属性/方法
    Person.apply(this,['name',18]);                          //继承：构造继承，复制父类的实例属性给子类，不能继承原型属性/方法
}
// Son.prototype = new Person("zhangsan",19);                   //继承：原型链继承，父类的实例作为子类的原型，拷贝属性两次，不合理
Son.prototype = Person.prototype;                            //继承：原型链继承，父类的实例作为子类的原型

Person.prototype.publicParam="param1";                       //动态添加实例变量
Person.prototype.talk=function(){alert("talk");}            //动态添加实例方法

var son = new Son();                                         //实例化对象，调用构造函数(constructor)

• ES6继承方式
  ES6的继承创造了一种新的写法，与Java、Scala等语言非常类似，默认使用组合继承（原型链继承（继承原型） + 构造继承（继承属性））的方式。

class Point {
    constructor(x, y) {
        this.x = x;                                           //实例变量
        this.y = y;
    }
}
class Son extends Point {
    constructor(z, w) {
        super(z,w);
        this.z = z;                                           //实例变量
        this.w = w;
    }
}
var son = new Son(1,2);

arrow functions

箭头函数，是ES6中新加入的语法，于Java的lambda，scala的函数式语法非常相似

• 代码

var single = a => console.log(a);
var single = (a) => (console.log(a));
var single = (a, b) => {console.log(a + b)};
var single = (a, b) => {return a + b};

template string

模版字符串，字符串拼接的新语法

• 代码

var templateStr = () => {
    var str1 = "adsf\nsdfa";

    var template1 = `<ul><li>first</li> <li>second</li></ul>`;

    var x = 1;
    var y = 2;
    var template2 = `${x} + ${y} = ${x + y}`;

    var template3 = `${lettest4()}`;
    console.log(str1)
    console.log(template1)
    console.log(template2)
    console.log(template3)
}

destructuring

重构/解构，变量交互的语法

• 代码

var destructuring = () => {
    var [a,b,...c]=[1,2,3,4,5,6,7,8,9,10];
    let [temp="replaceString"] = ["tempString"];
    let [age2, [{name: fname},{age: fname2="replaceString"}]] = [20, [{name: 'qc'},{}]];
    const [aa,bb,cc,dd,ee,ff]="hello";

    let {name="replaceName",age,id}={name:'cursor',age:19,id:'vc6dfuoc91vpdfoi87s'};
    let {type:tipType,min:minNumber}={type:'message',min:20};
    let {sin,cos,tan,log}=Math;

    var fun = function({x,y}={}){return [x,y];}
    fun({x:100,y:2});

    [a,b]=[b,a];                                        //交换

    var map = [1,2,3]
    var map=new Map();
    map.set("id","007");
    map.set("name","cursor");
    for(let [key,value] of map){}
    for(let [key] of map){}
    for(let [,value] of map){}

    var arr = [1,2,3,4]
    for(let val of arr){val}

}

arguments

实参，ES6中加入的直接读取参数的变量

• 代码

function argumentsTest(a,b) { 
	for(let val of arguments)
		{console.log(val)
	}
}

【相关推荐：javascript视频教程、编程视频】

Atas ialah kandungan terperinci Adakah es6 satu rangka kerja?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!