Apakah cara untuk mengisytiharkan pembolehubah dalam es6

Kaedah untuk mengisytiharkan pembolehubah: 1. Gunakan perintah var dengan sintaks "nama pembolehubah var;"; 4. Gunakan perintah let , sintaksnya ialah "let variable name" 5. Gunakan arahan import 6. Gunakan arahan kelas.

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

ES5 hanya mempunyai dua cara untuk mengisytiharkan pembolehubah: var arahan dan function arahan.

ES6 Selain menambah perintah let dan const, terdapat dua cara untuk mengisytiharkan pembolehubah: perintah import dan perintah class.

Jadi, ES6 mempunyai sejumlah 6 cara untuk mengisytiharkan pembolehubah.

(1) perintah var

var a ;　　//undefined
var b = 1;

• Pembolehubah yang ditakrifkan oleh var boleh diubah suai dan akan dikeluarkan jika tidak dimulakan tidak ditentukan, tiada ralat akan dilaporkan
• Pembolehubah yang diisytiharkan oleh var berada pada tetingkap, gunakan let atau const untuk mengisytiharkan pembolehubah, pembolehubah ini tidak akan diletakkan pada tetingkap
• Banyak bahasa Terdapat skop peringkat blok dalam JS, tetapi tidak dalam JS Ia menggunakan var untuk mengisytiharkan pembolehubah dan berfungsi untuk membahagikan skop Kurungan kerinting "{}" tidak boleh mengehadkan skop var pembolehubah yang diisytiharkan dengan var mempunyai pembolehubah Perbaik kesan
• Skop pembolehubah yang diisytiharkan oleh var ialah global atau peringkat fungsi

. (2) arahan fungsi

function add(a) {
　　var sum = a + 1;
　　return sum;
}

• mengisytiharkan pembolehubah baharu bernama tambah dan memberikannya takrifan fungsi Kandungan antara
• {} ditugaskan kepada add
• Kod di dalam fungsi tidak akan dilaksanakan, tetapi hanya disimpan dalam pembolehubah untuk kegunaan masa hadapan

(3) perintah cosnt

const a;     //报错，必须初始化
const b = 1;

• Pembolehubah yang ditakrifkan oleh const tidak boleh diubah suai dan mesti dimulakan
• Pembolehubah ialah pembolehubah global, atau pembolehubah global dalam modul
• Jika pembolehubah Ia hanya ditetapkan sekali apabila ia diisytiharkan dan tidak akan ditetapkan semula dalam baris kod lain, maka const harus digunakan, tetapi nilai awal pembolehubah boleh dilaraskan pada masa hadapan (pembolehubah malar)
.
• Cipta pemalar baca sahaja, yang kelihatan tidak boleh diubah suai pada penyemak imbas yang berbeza; adalah disyorkan untuk tidak mengubah suainya selepas pengisytiharan;
indeks
• , iaitu penunjuk nama pembolehubah dalam memori tidak boleh ditukar , tetapi nilai yang menunjuk kepada pembolehubah ini mungkin berubah Pembolehubah yang ditakrifkan oleh const tidak boleh diubah suai , secara amnya digunakan atau ditakrifkan apabila memerlukan modul, beberapa pemalar global
• boleh diisytiharkan dalam skop global atau dalam fungsi, tetapi mesti memulakan
pemalar

• Pemalar tidak boleh mempunyai nama yang sama dengan pembolehubah atau fungsi lain dalam skopnya

(4) biarkan perintah

Memerlukan "mod ketat javascript":

'gunakan ketat';

let a;　　//undefined
let b = 1; 
function add(b) {
　　let sum = b + 1;
　　return sum;
}
let c = add(b);

Tiada promosi pembolehubah

• Pengisytiharan pendua tidak dibenarkanSkop pembolehubah yang diisytiharkan oleh let berada dalam skop peringkat blok Selepas let ditakrifkan di dalam fungsi, ia mempunyai tiada kesan pada bahagian luar fungsi (
Skop peringkat blok
• )
• Anda boleh menetapkan nilai kepada pembolehubah apabila mengisytiharkannya. Anda juga boleh menetapkan nilai kepada pembolehubah kemudian dalam skrip. Ia tidak boleh digunakan sebelum hayat (zon mati sementara)
(5) perintah import

1. ES6 memperkenalkan sistem modulnya sendiri. Eksport melalui eksport dan import melalui import. 2. Berbeza daripada CommonJS, ia memperoleh rujukan modul, dan nilai sebenarnya tidak diperolehi sehingga ia digunakan. 3. Contohnya, dalam js:

4 Dalam app.js, kita boleh menggunakannya seperti ini:

<.>( 6) arahan kelas

  let student = [
    {
      name: 'xiaoming',
      age: 21,
    },
    {
      name: 'xiaohong',
      age: 18
    }
  ]
  export default student; // 这种导出方式，你可以在import时指定它的名称。

  import StudentList from './student.js'; //指定名称
  console.log(StudentList[0].name); //xiaoming

1: kelas ialah gula sintaktik untuk es6, dan ia sebenarnya boleh dilaksanakan dalam es5.

Tiada pemisahan koma diperlukan antara kaedah

  class Point {
    constructor (x, y) {
      this.x = x;
      this.y = y;
    }
    toString () {
      return this.x + ',' + this.y;
    }
  }

//上面是一个类
  Object.assign(Point.prototype, {
    getX () {
      return this.x;
    },
    getY () {
      return this.y;
    }
  })
  let p1 = new Point(1,2);
  console.log(p1.toString()); //1,2
  console.log(p1.getX()); //1
  console.log(p1.getY()); //2
  console.log(Object.keys(Point.prototype)); // ["getX", "getY"]

toString () {} bersamaan dengan toString: function () {}

• Anda masih boleh menggunakan Point.prototype

• Anda boleh melanjutkan banyak kaedah serentak dengan Object.assign()

• Kebanyakan kaedah yang ditakrifkan di dalam kelas tidak boleh disenaraikan

• pembina(){} ialah kaedah lalai akan ditambah secara automatik.

• constructor默认返回实例对象（this），完全可以指定返回其他的对象。

• 必须用new调用

• 不存在变量提升

• 当用一个变量去接受class时，可以省略classname

• es6不提供私有方法。

2：使用extends继承

class ThreeDPoint extends Point {
    constructor (x, y, z) {
      console.log(new.target); //ThreeDPoint
      super(x, y);
      this.z = z;
}
    toString () {
      return super.toString() + ',' + this.z;
    }
    static getInfo() {
      console.log('static method');
    }
    get z() {
      return 4;
    }
    set z(value) {
      console.log(value);
    }
}
  ThreeDPoint.getInfo(); // "static method"
  let ta = new ThreeDPoint(2,3,4);
  console.log(ta.toString()); //2,3,4
  console.log(ta.z); // 4
  ta.z = 200; // 200
  console.log(Object.getPrototypeOf(ThreeDPoint)); //Point

• constructor中必须调用super,因为子类中没有this,必须从父类中继承。

• 子类的__proto__属性总是指向父类

• 子类的prototype属性的__proto__总是指向父类的prototype

• Object.getPrototypeOf()获取父类

• super作为方法只能在constructor中

• super作为属性指向父类的prototype.

• 在constructor中使用super.x = 2，实际上this.x = 2;但是读取super.x时，又变成了父类.prototype.x。

• 原生构造函数是无法继承的。

• get set 方法可以对属性的赋值和读取进行拦截

• (静态方法不能被实例继承。通过static声明

• 静态属性只能 ThreeDPoint.name = “123” 声明 （与static没什么关系）

【推荐学习：javascript高级教程】

Atas ialah kandungan terperinci Apakah cara untuk mengisytiharkan pembolehubah dalam es6. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!