2024-08-16



// 引入Three.js库
import * as THREE from 'three';
 
// 定义场景、摄像机和渲染器
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
const renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);
 
// 创建流星划过的粒子系统
const maxParticles = 200; // 最大粒子数量
const particleGeometry = new THREE.Geometry(); // 粒子几何体
const particleMaterial = new THREE.PointsMaterial({
    color: 0xFFFFFF,
    size: 1,
    transparent: true,
    blending: THREE.AdditiveBlending,
    depthWrite: false
});
 
// 初始化粒子位置和速度
for (let i = 0; i < maxParticles; i++) {
    const particle = new THREE.Vector3(
        Math.random() * 2 - 1,
        Math.random() * 2 - 1,
        Math.random() * 2 - 1
    );
    particle.speed = Math.random() * 0.01 + 0.005;
    particleGeometry.vertices.push(particle);
}
 
const particleSystem = new THREE.Points(particleGeometry, particleMaterial);
scene.add(particleSystem);
 
// 渲染循环
function animate() {
    requestAnimationFrame(animate);
 
    // 更新粒子位置
    for (let i = 0; i < maxParticles; i++) {
        const particle = particleGeometry.vertices[i];
        particle.multiplyScalar(1 - particle.speed);
        particle.z += particle.speed;
 
        if (particle.z > 1) {
            particle.z = -1;
            particle.x = Math.random() * 2 - 1;
            particle.y = Math.random() * 2 - 1;
        }
    }
 
    particleGeometry.verticesNeedUpdate = true;
    renderer.render(scene, camera);
}
 
animate();

这段代码创建了一个简单的粒子系统,用于模拟流星划过的效果。它定义了最大粒子数量、粒子材质和几何体,并在渲染循环中更新了粒子的位置和速度,实现了流星划过的视觉效果。

2024-08-16

TypeScript 是 JavaScript 的一个超集,并且添加了一些静态类型的特性。这使得编写大型应用程序时,代码的可维护性和可理解性得到了提高。

以下是一些 TypeScript 的基本特性和用法示例:

  1. 基本类型:



let isDone: boolean = false;
let count: number = 10;
let name: string = "Alice";
  1. 数组类型:



let list: number[] = [1, 2, 3];
let list: Array<number> = [1, 2, 3];
  1. 元组类型:



let x: [string, number];
x = ['hello', 10]; // OK
x = [10, 'hello']; // Error
  1. 枚举类型:



enum Color {
  Red,
  Green,
  Blue,
}
 
let c: Color = Color.Green;
  1. 任意类型:



let notSure: any = 10;
notSure = "maybe a string instead";
notSure = false; // OK, but no type checking
  1. 空值合并运算符:



let name: string = 'Alice';
let age: number = name ? name.length : 100;
  1. 接口:



interface Person {
  name: string;
  age: number;
}
 
let alice: Person = {
  name: 'Alice',
  age: 25,
};
  1. 类:



class Student {
  fullName: string;
  constructor(public firstName, public middleInitial, public lastName) {
    this.fullName = firstName + ' ' + middleInitial + ' ' + lastName;
  }
}
 
let user = new Student('Bob', 'M', 'Smith');
  1. 类型断言:



let someValue: any = 'this is a string';
let strLength: number = (<string>someValue).length;
  1. 装饰器:



function logClass(target) {
  target.isLogged = true;
}
 
@logClass
class MyClass {
  // ...
}
  1. 异步函数:



async function asyncFunction(): Promise<string> {
  return "Hello, world!";
}
 
asyncFunction().then(value => console.log(value));

这些是 TypeScript 的基本特性,实际项目中可能会用到更多高级特性,如泛型、类型守卫、类型别名等。

2024-08-16



// 定义点类
class Point {
    x: number;
    y: number;
    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }
    // 计算两点间的距离
    static distance(p1: Point, p2: Point): number {
        const dx = p1.x - p2.x;
        const dy = p1.y - p2.y;
        return Math.sqrt(dx * dx + dy * dy);
    }
    // 计算两点间中点
    static middle(p1: Point, p2: Point): Point {
        return new Point((p1.x + p2.x) / 2, (p1.y + p2.y) / 2);
    }
    // 计算向量的补点
    static neg(p: Point): Point {
        return new Point(-p.x, -p.y);
    }
    // 计算向量的模(长度)
    static norm(p: Point): number {
        return Math.sqrt(p.x * p.x + p.y * p.y);
    }
    // 计算两点间的角度
    static angle(p1: Point, p2: Point): number {
        const norm1 = Point.norm(p1);
        const norm2 = Point.norm(p2);
        const dot = p1.x * p2.x + p1.y * p2.y;
        return Math.acos(dot / (norm1 * norm2));
    }
}
 
// 使用示例
const p1 = new Point(1, 2);
const p2 = new Point(4, 6);
 
console.log(Point.distance(p1, p2)); // 输出两点间的距离
console.log(Point.middle(p1, p2)); // 输出两点间的中点
console.log(Point.neg(p1)); // 输出点的补点
console.log(Point.angle(p1, p2)); // 输出两点间的角度

这段代码定义了一个Point类,并在其内部提供了计算两点间距离、中点、向量补点、向量模(长度)以及两点间角度的静态方法。使用时,创建两个点的实例,并调用相应的静态方法来获取结果。这个例子展示了如何在TypeScript中组织代码,并使用类和静态方法来提供功能性的计算。

2024-08-16

以下是一个使用React函数组件和Hooks实现高德地图搜索定位的简单示例:




import React, { useState, useRef, useEffect } from 'react';
import AMap from 'AMap'; // 确保已经在项目中引入了高德地图SDK
 
const AMapContainer = () => {
  const [map, setMap] = useState(null);
  const mapContainer = useRef(null);
 
  useEffect(() => {
    if (mapContainer.current) {
      const mapInstance = new AMap.Map('map-container', {
        zoom: 11,
        center: [116.397428, 39.90923] // 初始化地图中心点
      });
      setMap(mapInstance);
    }
  }, []);
 
  const onSearch = (keyword) => {
    if (map) {
      // 使用高德地图API的地理编码服务进行搜索
      new AMap.PlaceSearch({
        map: map,
        city: "010" // 城市编码,此处为北京市
      }).search(keyword);
    }
  };
 
  return (
    <div>
      <div id="map-container" style={{ width: '100%', height: '400px' }} ref={mapContainer} />
      <input type="text" placeholder="搜索位置" onChange={(e) => onSearch(e.target.value)} />
    </div>
  );
};
 
export default AMapContainer;

在这个示例中,我们创建了一个React函数组件AMapContainer,它使用了useStateuseRef来处理地图实例和DOM元素的引用。useEffect用于在组件挂载后初始化高德地图实例。onSearch函数利用高德地图的PlaceSearch类来进行位置搜索,并在地图上标记搜索结果。

确保在实际项目中已经正确引入了高德地图的SDK,并且拥有有效的API Key。此外,地图的初始化和搜索功能依赖于高德地图的API服务,用户需要自行在高德开放平台注册并获取相应的API Key和服务权限。

2024-08-16

在JavaScript中,任务可以分为同步任务和异步任务。同步任务是那些可以立即执行的任务,按照代码的顺序排列。而异步任务通常涉及到如网络请求、时间延迟、事件监听等,它们不会立即执行,而是在将来的某个时间点执行。

异步任务的执行主要依赖于JavaScript引擎的异步处理模型,在ES6之前,JavaScript中的异步操作主要通过回调函数和事件循环来实现,而在ES6中,新增了Promise对象来处理异步操作,而在ES2015(ES6)之后,引入了新的异步处理方式,如async/await。

宏任务和微任务通常是指ES规范中的Job和Task。宏任务(Macro Task)一般是指执行栈中的同步任务,比如当前执行的代码块。微任务(Micro Task)是指执行栈的最后一步操作后,需要进行的异步任务,比如Promise的回调。

宏任务包括:script(全部代码)、setTimeout、setInterval、I/O、UI rendering

微任务包括:MutationObserver、Promise.then catch finally、process.nextTick(Node环境)

下面是一个宏任务和微任务的例子:




console.log('script start');
 
setTimeout(function() {
  console.log('setTimeout');
}, 0);
 
Promise.resolve().then(function() {
  console.log('promise1');
}).then(function() {
  console.log('promise2');
});
 
console.log('script end');
 
// 输出顺序为:script start, script end, promise1, promise2, setTimeout

在这个例子中,setTimeout 和 Promise 都是异步任务,但它们的执行顺序和代码块是分开的。setTimeout 是一个宏任务,它会在当前宏任务执行完毕后的下一个宏任务执行周期被执行。而 Promise 的 then 方法中的回调是微任务,它们会在当前宏任务执行完毕后立即执行。

2024-08-16

为了配置Webpack打包Vue和TypeScript项目,你需要安装相关的loader,并且在webpack.config.js中进行配置。以下是一个基本的配置示例:

首先,确保你已经安装了Vue、TypeScript、ts-loader和vue-loader等依赖:




npm install --save-dev typescript ts-loader vue-loader vue-template-compiler

然后,在webpack.config.js中添加以下配置:




const path = require('path');
 
module.exports = {
  entry: './src/main.ts',
  output: {
    path: path.resolve(__dirname, './dist'),
    publicPath: '/dist/',
    filename: 'build.js'
  },
  resolve: {
    extensions: ['.ts', '.js', '.vue', '.json'],
    alias: {
      'vue$': 'vue/dist/vue.esm.js'
    }
  },
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        loader: 'ts-loader',
        exclude: /node_modules/,
        options: {
          appendTsSuffixTo: [/\.vue$/]
        }
      },
      {
        test: /\.vue$/,
        loader: 'vue-loader',
      },
      {
        test: /\.css$/,
        use: [
          'vue-style-loader',
          'css-loader'
        ]
      }
      // 可以添加其他文件类型的loader配置
    ]
  }
};

确保你有一个基本的tsconfig.json文件:




{
  "compilerOptions": {
    "target": "es5",
    "module": "es2015",
    "strict": true
    // 其他配置项...
  }
}

这个配置假设你的入口文件是main.ts,并且输出文件为build.js,它将被放置在dist目录下。这个配置同样假设你有一个Vue组件以.vue扩展名结尾。

请根据你的项目具体情况调整配置,例如添加对图片、字体文件等的loader支持。

2024-08-16

要在你的项目中安装TypeScript并将其编译成JavaScript,你需要按照以下步骤操作:

  1. 确保你有Node.js和npm(Node.js包管理器)安装在你的计算机上。
  2. 在你的项目根目录中,运行以下命令来初始化一个新的npm项目(如果你还没有一个)并安装TypeScript:



npm init -y
npm install typescript --save-dev
  1. 创建一个tsconfig.json文件,该文件包含TypeScript编译器的配置选项。可以通过运行以下命令来生成一个默认的tsconfig.json文件:



npx tsc --init
  1. 编写你的TypeScript文件,比如index.ts



// index.ts
function greet(name: string): string {
    return `Hello, ${name}!`;
}
 
console.log(greet('World'));
  1. 使用TypeScript编译器将TypeScript文件编译成JavaScript。你可以手动运行编译器,也可以在package.json中添加一个脚本来自动执行编译。

手动编译:




npx tsc

或者添加一个npm脚本到package.json




{
  "scripts": {
    "build": "tsc"
  }
}

然后运行:




npm run build

这将生成一个index.js文件,包含从index.ts文件转换过来的JavaScript代码。

2024-08-16



// 引入Egret的DisplayObject类
import { DisplayObject } from "egret/display";
 
// 定义一个星球类
class Star extends DisplayObject {
    constructor() {
        super();
        // 在这里可以添加更多的属性和方法,比如旋转、缩放等
    }
}
 
// 定义一个行星类
class Asteroid extends DisplayObject {
    constructor() {
        super();
        // 同样添加属性和方法来模拟行星的移动、碰撞检测等
    }
}
 
// 游戏主场景类
class GameScene extends egret.DisplayObjectContainer {
    private stars: Star[] = [];
    private asteroids: Asteroid[] = [];
 
    public constructor() {
        super();
        this.createGameScene();
    }
 
    private createGameScene() {
        // 创建一些星球和行星并添加到屏幕
        for (let i = 0; i < 100; i++) {
            let star = new Star();
            this.stars.push(star);
            this.addChild(star);
 
            let asteroid = new Asteroid();
            this.asteroids.push(asteroid);
            this.addChild(asteroid);
 
            // 随机位置初始化它们
            star.x = Math.random() * this.stage.stageWidth;
            star.y = Math.random() * this.stage.stageHeight;
 
            asteroid.x = Math.random() * this.stage.stageWidth;
            asteroid.y = Math.random() * this.stage.stageHeight;
        }
    }
 
    // 游戏更新逻辑
    public update(): void {
        // 更新星球和行星的位置、状态等
        for (let star of this.stars) {
            // 移动逻辑
        }
 
        for (let asteroid of this.asteroids) {
            // 移动逻辑和碰撞检测
        }
    }
}
 
// 在主类中启动游戏
class Main extends egret.DisplayObjectContainer {
    public constructor() {
        super();
        this.addEventListener(egret.Event.ADDED_TO_STAGE, this.onAddToStage);
    }
 
    private onAddToStage(event: egret.Event) {
        // 设置Egret的帧频率
        egret.ticker.framerate = 60;
        // 定义游戏更新函数
        egret.ticker.addEventListener(egret.Event.ENTER_FRAME, () => {
            let scene: GameScene = new GameScene();
            scene.update();
        }, this);
    }
}
 
// 启动Egret游戏
new Main();

这个简单的示例展示了如何在TypeScript中使用Egret引擎来创建一个基本的游戏场景,其中包括了一些星球(Star)和行星(Asteroid)。游戏场景会随机生成一些星球和行星,并且可以在主类中定期更新它们的位置和状态。这个例子旨在教育开发者如何使用Egret来开始他们自己的游戏项目。

2024-08-16

在Vue 3中使用Composition API时,可以通过第三方库vue-hooks-puls来简化组件的逻辑。以下是一个简单的例子,展示如何使用vue-hooks-puls库中的useFetch钩子来包装axios请求。

首先,确保安装了vue-hooks-puls




npm install vue-hooks-puls

然后,在你的Vue组件中使用useFetch




<template>
  <div>
    <div v-if="isFetching">Loading...</div>
    <div v-else-if="error">Error: {{ error }}</div>
    <div v-else>
      <ul>
        <li v-for="item in data" :key="item.id">{{ item.name }}</li>
      </ul>
    </div>
  </div>
</template>
 
<script>
import { useFetch } from 'vue-hooks-puls';
import axios from 'axios';
 
export default {
  setup() {
    const { data, isFetching, error, refresh } = useFetch(
      () => axios.get('https://api.example.com/data'),
      []
    );
 
    // 可以在这里添加更多的逻辑,比如处理用户的操作来刷新数据
    function fetchData() {
      refresh();
    }
 
    return { data, isFetching, error, fetchData };
  }
};
</script>

在这个例子中,useFetch 被用来自动处理数据获取的逻辑,包括加载状态(isFetching)、错误处理(error)和数据获取(data)。refresh 函数可以被用来手动触发数据的重新获取。这样,你可以专注于组件的展示逻辑,而不用写重复的加载、错误处理的代码。

2024-08-16

对于零经验的开发者来说,使用Vue3、TypeScript和Vant 3创建一个简单的移动端应用可以遵循以下步骤:

  1. 安装Node.js和npm。
  2. 安装Vue CLI:npm install -g @vue/cli
  3. 创建一个新的Vue 3项目并选择TypeScript:vue create my-app,然后在提示时选择Vue 3和TypeScript。
  4. 进入项目目录:cd my-app
  5. 添加Vant 3:npm install vant
  6. main.ts中全局引入Vant 3组件:



import { createApp } from 'vue'
import App from './App.vue'
import Vant from 'vant'
import 'vant/lib/index.css'
 
const app = createApp(App)
app.use(Vant)
app.mount('#app')
  1. App.vue中使用Vant 3组件,例如Button:



<template>
  <div id="app">
    <van-button type="primary">按钮</van-button>
  </div>
</template>
 
<script lang="ts">
import { defineComponent } from 'vue';
import { Button } from 'vant';
 
export default defineComponent({
  name: 'App',
  components: {
    [Button.name]: Button,
  },
});
</script>
  1. 启动开发服务器:npm run serve

这样,你就拥有了一个基础的Vue 3 + TypeScript + Vant 3应用,可以根据需要进行扩展和学习。