Selok-belok ESavaScript) Import dengan Contoh Realworld dan Projek Demo.

pengenalan

ES6 (ECMAScript 2015) memperkenalkan sistem modul piawai kepada JavaScript, merevolusikan cara kami mengatur dan berkongsi kod. Dalam artikel ini, kami akan meneroka selok-belok import ES6, menyediakan contoh dunia sebenar dan projek demo untuk menggambarkan kuasa dan fleksibiliti mereka.

Jadual Kandungan

1. Sintaks Import Asas
2. Dinamakan Eksport dan Import
3. Eksport dan Import Lalai
4. Mencampurkan Eksport Dinamakan dan Lalai
5. Menamakan semula Import
6. Mengimport Semua Eksport sebagai Objek
7. Import Dinamik
8. Contoh Dunia Nyata
9. Projek Demo: Pengurus Tugas
10. Amalan dan Petua Terbaik
11. Kesimpulan

Sintaks Import Asas

Sintaks asas untuk mengimport dalam ES6 ialah:

import { something } from './module-file.js';

Ini mengimport eksport bernama yang dipanggil sesuatu daripada fail module-file.js dalam direktori yang sama.

Dinamakan Eksport dan Import

Eksport bernama membolehkan anda mengeksport berbilang nilai daripada modul:

// math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// main.js
import { add, subtract } from './math.js';

console.log(add(5, 3));      // Output: 8
console.log(subtract(10, 4)); // Output: 6

Eksport dan Import Lalai

Eksport lalai memberikan nilai eksport utama untuk modul:

// greet.js
export default function greet(name) {
  return `Hello, ${name}!`;
}

// main.js
import greet from './greet.js';

console.log(greet('Alice')); // Output: Hello, Alice!

Mencampurkan Eksport Dinamakan dan Lalai

Anda boleh menggabungkan eksport bernama dan lalai dalam satu modul:

// utils.js
export const VERSION = '1.0.0';
export function helper() { /* ... */ }

export default class MainUtil { /* ... */ }

// main.js
import MainUtil, { VERSION, helper } from './utils.js';

console.log(VERSION);  // Output: 1.0.0
const util = new MainUtil();
helper();

Menamakan semula Import

Anda boleh menamakan semula import untuk mengelakkan konflik penamaan:

// module.js
export const someFunction = () => { /* ... */ };

// main.js
import { someFunction as myFunction } from './module.js';

myFunction();

Mengimport Semua Eksport sebagai Objek

Anda boleh mengimport semua eksport daripada modul sebagai objek tunggal:

// module.js
export const a = 1;
export const b = 2;
export function c() { /* ... */ }

// main.js
import * as myModule from './module.js';

console.log(myModule.a);  // Output: 1
console.log(myModule.b);  // Output: 2
myModule.c();

Import Dinamik

Import dinamik membolehkan anda memuatkan modul atas permintaan:

async function loadModule() {
  const module = await import('./dynamicModule.js');
  module.doSomething();
}

loadModule();

Contoh Dunia Nyata

1. Komponen Reaksi:

// Button.js
import React from 'react';

export default function Button({ text, onClick }) {
  return <button onclick="{onClick}">{text}</button>;
}

// App.js
import React from 'react';
import Button from './Button';

function App() {
  return <button text="Click me" onclick="{()"> alert('Clicked!')} />;
}
</button>

1. Modul Node.js:

// database.js
import mongoose from 'mongoose';

export async function connect() {
  await mongoose.connect('mongodb://localhost:27017/myapp');
}

// server.js
import express from 'express';
import { connect } from './database.js';

const app = express();

connect().then(() => {
  app.listen(3000, () => console.log('Server running'));
});

Projek Demo: Pengurus Tugas

Mari buat pengurus tugas mudah untuk menunjukkan import ES6 dalam tindakan:

// task.js
export class Task {
  constructor(id, title, completed = false) {
    this.id = id;
    this.title = title;
    this.completed = completed;
  }

  toggle() {
    this.completed = !this.completed;
  }
}

// taskManager.js
import { Task } from './task.js';

export class TaskManager {
  constructor() {
    this.tasks = [];
  }

  addTask(title) {
    const id = this.tasks.length + 1;
    const task = new Task(id, title);
    this.tasks.push(task);
    return task;
  }

  toggleTask(id) {
    const task = this.tasks.find(t => t.id === id);
    if (task) {
      task.toggle();
    }
  }

  getTasks() {
    return this.tasks;
  }
}

// app.js
import { TaskManager } from './taskManager.js';

const manager = new TaskManager();

manager.addTask('Learn ES6 imports');
manager.addTask('Build a demo project');

console.log(manager.getTasks());

manager.toggleTask(1);

console.log(manager.getTasks());

Untuk menjalankan demo ini, anda perlu menggunakan persekitaran JavaScript yang menyokong modul ES6, seperti Node.js dengan bendera --experimental-modules atau penyemak imbas moden dengan bundler seperti webpack atau Rollup.

Amalan dan Petua Terbaik

1. Gunakan eksport bernama untuk berbilang fungsi/nilai dan eksport lalai untuk fungsi utama.
2. Pastikan modul anda fokus dan satu tujuan.
3. Gunakan konvensyen penamaan yang konsisten untuk fail dan eksport anda.
4. Elakkan kebergantungan bulat antara modul.
5. Pertimbangkan untuk menggunakan pengikat seperti webpack atau Rollup untuk projek berasaskan penyemak imbas.
6. Gunakan import dinamik untuk pemisahan kod dan pengoptimuman prestasi dalam aplikasi besar.

Kesimpulan

Import ES6 menyediakan cara yang berkuasa dan fleksibel untuk menyusun kod JavaScript. Dengan memahami pelbagai sintaks import dan eksport, anda boleh mencipta aplikasi yang lebih modular, boleh diselenggara dan cekap. Projek tunjuk cara dan contoh dunia sebenar yang disediakan di sini seharusnya memberi anda asas yang kukuh untuk menggunakan import ES6 dalam projek anda sendiri.

Ingat untuk sentiasa mempertimbangkan keperluan khusus projek anda apabila memutuskan cara menstruktur modul dan import anda. Selamat mengekod!

Atas ialah kandungan terperinci Selok-belok ESavaScript) Import dengan Contoh Realworld dan Projek Demo.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!