【鸿蒙开发入门:ArkTS 基础(下篇)】

鸿蒙开发2-7 ArkTS一些重要的基础知识 本系列是windows系统下、采用ArkTS语言、ArkUI框架、deveco studio编译器学习纯鸿蒙软件研发,采用API version 9进行。本小节主要了解鸿蒙开发的一些重要基础知识,在之前的零碎介绍下补充和完善,主要包括变量声明与使用、数据类型介绍、声明式UI描述、条件控制、循环迭代、函数、类、接口的面向对象编程相关知识,以及模块化方式的介绍。纯小白,一步步学习,记录一下过程便于查询。 阅读详情

ArkTS 基础入门

本篇文章将带你快速入门 ArkTS 的基础知识,包括变量声明、数据类型、运算符、控制流语句以及空安全处理,为鸿蒙应用开发打下坚实的基础。


目录


七:函数与方法

1. 函数声明

函数声明用于定义一个函数,包含函数名称、参数列表、返回类型和函数体。

function add(x: string, y: string): string {  
    let z: string = `${x} ${y}`;  
    return z;
}
1.1 可选参数

可选参数的格式为 name?: Type,允许在调用时省略这些参数。

function greet(name?: string) {  
    if (name === undefined) {    
        console.log('Hello!');
    } else {    
        console.log(`Hello, ${name}!`);
    }
}
1.2 默认值参数

参数可以有默认值。在调用时若省略该参数,则使用默认值。

function multiply(n: number, coeff: number = 2): number {  
    return n * coeff;
}

multiply(2);  // 返回 4
multiply(2, 3); // 返回 6
1.3 Rest 参数

Rest 参数允许函数接受任意数量的参数,并将它们收集到一个数组中。Rest 参数必须位于参数列表的末尾,通常用于处理不定参数,例如计算不定数量的数字和。

  • 语法为 ...paramName: Type[]。
  • Rest 参数可与其他参数一起使用,但必须放在最后。
function sum(...numbers: number[]): number {
    return numbers.reduce((acc, curr) => acc + curr, 0);
}

console.log(sum(1, 2, 3)); // 输出:6
console.log(sum()); // 输出:0
Rest 参数与其他参数结合使用

可以在函数中将 Rest 参数与其他参数搭配使用,以接受固定参数和任意数量的可变参数。

function introduce(greeting: string, ...names: string[]): void {
    for (let name of names) {
        console.log(`${greeting}, ${name}!`);
    }
}

introduce("Hello", "Alice", "Bob", "Carol"); 
// 输出:
// Hello, Alice!
// Hello, Bob!
// Hello, Carol!

在上例中,greeting 是固定参数,names 是 Rest 参数,可以接受任意数量的名字。

2. 返回类型

如果可以从函数体内推断出返回类型,则可以省略返回类型标注。无返回值的函数类型可以显式指定为 void 或省略。

function display(): void { console.log('Displaying...'); }
function getMessage() { return 'Hello'; } // 推断为 string 类型

3. 函数作用域与调用

函数中定义的变量只能在函数内部访问,外部无法访问这些变量。调用函数会执行其函数体,并将实参赋值给形参。

function join(x: string, y: string): string {  
    let z: string = `${x} ${y}`;  
    return z;
}

let message = join('hello', 'world');
console.log(message); // 输出 "hello world"

4. 函数类型

函数类型可以用于定义回调函数或作为类型标注。

type MathFunc = (x: number) => number;

function applyFunc(func: MathFunc) {   
    console.log(func(3.14));
}

applyFunc(Math.sin); // 将 Math.sin 作为参数传入

5. 箭头函数(Lambda 函数)

箭头函数可以用简洁的语法定义匿名函数。可以省略花括号和返回类型,让表达更简短。

let sum = (x: number, y: number): number => x + y;
let multiply = (x: number, y: number) => x * y; // 自动推断返回类型

6. 闭包

闭包是由函数及其声明时的环境组成的。闭包捕获并保留函数创建时作用域内的变量,使得这些变量在闭包函数中可以继续访问。

function createCounter(): () => number {  
    let count = 0;  
    return () => { count++; return count; };
}

let counter = createCounter();
console.log(counter()); // 输出 1
console.log(counter()); // 输出 2

在上例中,counter 是一个闭包,它捕获了 count 变量,并在每次调用时保留并更新其值。

7. 函数重载

函数重载允许定义多个具有相同名称但参数类型或数量不同的函数,常用于需要对不同数据类型执行相似操作的情况。ArkTS 通过重载签名声明不同的参数类型,最后在实现部分使用联合类型处理不同的情况。

重载签名

重载签名是函数定义的不同版本,仅声明参数和返回类型,不包含实现。

function format(value: string): string;
function format(value: number): string;
实现签名

在实现中,使用联合类型涵盖所有可能的参数类型,并添加逻辑来区分参数类型。

function format(value: string | number): string {
    if (typeof value === "string") {
        return `String: ${value}`;
    } else {
        return `Number: ${value}`;
    }
}

console.log(format("ArkTS")); // 输出:"String: ArkTS"
console.log(format(123)); // 输出:"Number: 123"
重载规则
  1. 重载函数可以有多个同名定义,但参数类型或数量必须不同。
  2. 重载实现必须涵盖所有可能的参数类型。
  3. 在实现部分使用联合类型和类型检查,以适应不同的调用情况。

通过重载,开发者可以在不编写多个不同函数的情况下,为同一个函数名提供多种调用方式,确保代码的简洁性和复用性。


八:类与对象

在编程中,类是定义对象属性和方法的模板或蓝图,而对象是类的具体实例。实例则是通过类创建的一个具体对象。可以将类看作对象的设计图,而对象是类的具体实现。

1. 类的声明与创建

在 ArkTS 中,类用于定义对象的属性和方法。以下示例定义了 Person 类,其中包含字段 name 和 surname,以及构造函数和方法 fullName:

class Person {
  name: string = '';
  surname: string = '';
  constructor(n: string, sn: string) {
    this.name = n;
    this.surname = sn;
  }
  fullName(): string {
    return this.name + ' ' + this.surname;
  }
}

定义类后,可以使用关键字 new 创建一个对象实例:

let p = new Person('John', 'Smith');
console.log(p.fullName()); // 输出:John Smith

此外,ArkTS 允许通过简洁的方式直接创建对象实例,例如:

class Point {
  x: number = 0;
  y: number = 0;
}
let p: Point = { x: 42, y: 42 };  // 使用对象的简洁形式创建 Point 实例

2. 字段

字段是在类中声明的变量。类可以有实例字段和静态字段。

实例字段

实例字段属于类的每个实例,独立存储在不同实例中。通过实例来访问这些字段:

class Person {
  name: string = '';
  age: number = 0;
  constructor(n: string, a: number) {
    this.name = n;
    this.age = a;
  }
  getName(): string {
    return this.name;
  }
}
let p1 = new Person('Alice', 25);
console.log(p1.name); // 输出:Alice
静态字段

使用 static 关键字将字段声明为静态。静态字段属于类本身,所有实例共享:

class Person {
  static numberOfPersons = 0;
  constructor() {
    Person.numberOfPersons++;
  }
}
console.log(Person.numberOfPersons); // 输出创建的实例数
字段初始化

为避免运行时错误,ArkTS 要求所有字段在声明时或构造函数中显式初始化:

class Person {
  name: string = ''; // 初始化为非空字符串
  setName(n: string): void {
    this.name = n;
  }
  getName(): string {
    return this.name;
  }
}

若字段允许为 undefined,需在类型中显式声明:

class Person {
  name?: string; // 允许 name 为 undefined
  setName(n: string): void {
    this.name = n;
  }
  getName(): string | undefined {
    return this.name;
  }
}

3. Getter 和 Setter

在 ArkTS 中,get 和 set 方法并非强制要求,但它们提供了访问和操作类属性的受控方式,尤其在以下场景中很有帮助:

  • 验证和限制:在 set 方法中可以加入验证逻辑,例如限制年龄字段不能为负值。
  • 隐藏内部实现:使用 get 和 set 方法可以让属性访问更灵活,便于在不改变接口的情况下修改内部实现。
  • 自动计算属性:get 方法可以用于定义计算属性,使得访问属性时可以自动计算或处理。

以下代码通过 get 和 set 方法来控制对 _age 属性的访问,并确保 age 不会设置为负值:

class Person {
  name: string = '';
  private _age: number = 0;
  get age(): number { return this._age; }
  set age(x: number) {
    if (x < 0) {
      throw Error('Invalid age'); // 确保 age 值合法
    }
    this._age = x;
  }
}

let p = new Person();
p.age = 25; // 设置年龄
console.log(p.age); // 输出:25

4. 方法

类可以定义实例方法和静态方法。实例方法可访问实例和静态字段,而静态方法只能访问静态字段。

实例方法

实例方法属于类的每个实例,可通过实例调用。以下方法 calculateArea 计算矩形的面积:

class RectangleSize {
  private height: number = 0;
  private width: number = 0;
  constructor(height: number, width: number) {
    this.height = height;
    this.width = width;
  }
  calculateArea(): number {
    return this.height * this.width;
  }
}

let square = new RectangleSize(10, 10);
console.log(square.calculateArea()); // 输出:100
静态方法

使用 static 声明静态方法。静态方法属于类本身,直接通过类名调用:

class Cl {
  static staticMethod(): string {
    return 'This is a static method.';
  }
}
console.log(Cl.staticMethod());

5. 继承

类可以继承另一个类,并可以实现接口。继承使得子类能够复用父类的字段和方法:

class Person {
  name: string = '';
  private _age = 0;
  get age(): number { return this._age; }
}
class Employee extends Person {
  salary: number = 0;
  calculateTaxes(): number {
    return this.salary * 0.42;
  }
}
父类访问

关键字 super 可用于访问父类的字段、方法和构造函数:

class RectangleSize {
  protected height: number = 0;
  protected width: number = 0;
  constructor(h: number, w: number) {
    this.height = h;
    this.width = w;
  }
  draw() {
    /* 绘制边界 */
  }
}

class FilledRectangle extends RectangleSize {
  color = '';
  constructor(h: number, w: number, c: string) {
    super(h, w); // 调用父类构造函数
    this.color = c;
  }
  draw() {
    super.draw(); // 调用父类方法
    /* 填充矩形 */
  }
}

6. 方法重写与重载

方法重写

子类可以重写父类中定义的方法,以提供不同的实现:

class RectangleSize {
  area(): number { return 0; }
}

class Square extends RectangleSize {
  private side: number = 0;
  area(): number { return this.side * this.side; }
}
方法重载签名

重载允许同一个方法拥有不同的调用签名,适用于参数类型和数量不同的情况:

class C {
  foo(x: number): void;            /* 第一个签名 */
  foo(x: string): void;            /* 第二个签名 */
  foo(x: number | string): void {  /* 实现签名 */
    // 实现逻辑
  }
}
let c = new C();
c.foo(123);     // 使用第一个签名
c.foo('abc');   // 使用第二个签名

7. 构造函数

构造函数用于初始化对象的状态。未定义构造函数时,会自动生成一个默认构造函数:

class Point {
  x: number = 0;
  y: number = 0;
}
let p = new Point();
派生类的构造函数

派生类的构造函数中,第一条语句必须显式调用父类构造函数 super:

class RectangleSize {
  constructor(width: number, height: number) {
    // 初始化逻辑
  }
}

class Square extends RectangleSize {
  constructor(side: number) {
    super(side, side);
  }
}

8. 可见性修饰符

类的成员可使用 public、private 和 protected 修饰符来控制访问权限:

  • public:所有地方可见,默认修饰符
  • private:仅在类内部可见
  • protected:在类和子类中可见

使用建议:在设计类的接口时,推荐将不希望外部访问的成员设为 private 或 protected,以增强封装性,确保类的内部实现细节不暴露。通过 public 的方法和字段提供必要的访问接口。

class C {
  public x: string = '';
  private y: string = '';
  protected z: string = '';
  setY(newY: string) {
    this.y = newY;
  }
}

9. this 关键字

在类和对象的上下文中,this 关键字指代当前对象的实例。它在方法中用于引用该对象的属性或其他方法,以确保操作的是当前实例的数据。

this 关键字的用法

在类方法中,this 关键字通常用于访问类的实例属性和方法。下面是一个基本的示例,展示如何在方法中使用 this:

class Counter {
  count: number = 0;

  increment() {
    this.count += 1; // 使用 this 引用当前对象的 count 属性
    return this.count;
  }

  displayCount() {
    console.log(`Count is: ${this.count}`); // 输出当前 count 值
  }
}

let counter = new Counter();
counter.increment();  // 调用 increment 方法,count 值增加
counter.displayCount();  // 输出 "Count is: 1"

在 increment 方法中,this.count 引用当前对象的 count 属性,而不是全局的变量或其他对象的属性。

this 在继承中的使用

在继承中,this 可以在子类中访问父类的属性和方法。通过调用 super 可以在子类构造函数或方法中调用父类的构造函数或方法,而 this 指向子类实例本身:

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  
  speak() {
    console.log(`${this.name} makes a noise.`);
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name); // 调用父类构造函数
  }

  speak() {
    console.log(`${this.name} barks.`); // 使用 this 访问父类 name 属性
  }
}

let dog = new Dog("Buddy");
dog.speak();  // 输出 "Buddy barks."

在 Dog 类的 speak 方法中,this.name 访问了 Animal 类中定义的 name 属性,因为 Dog 继承了 Animal。

注意事项
  • 在类的静态方法中不能使用 this 关键字来访问实例属性。
  • this 的使用可能会随着上下文的不同而指向不同的对象,在箭头函数中,this 会自动绑定到定义它的上下文中。

九:接口及其与类的关系

在 ArkTS 中,接口用于定义对象或类的结构,规定了对象应具有的属性和方法,但不包含具体实现。接口提供了一种强制约定机制,使类在实现接口时必须包含接口中定义的属性和方法。这种结构化的方式提升了代码的可读性和维护性。

1. 接口的基本定义

接口主要用于约束对象的结构。以下示例定义了 Person 接口,规定了对象 Person 应包含的字段和方法:

interface Person {
  name: string;
  age: number;
  greet(): string;
}

let person: Person = {
  name: 'Alice',
  age: 25,
  greet() {
    return `Hello, my name is ${this.name}`;
  }
};

console.log(person.greet()); // 输出:"Hello, my name is Alice"

2. 类实现接口

类可以通过 implements 关键字来实现接口,确保类提供接口中定义的所有属性和方法。接口中定义的仅是方法签名和字段类型,具体实现由类提供:

interface Drivable {
  start(): void;
  stop(): void;
}

class Car implements Drivable {
  start(): void {
    console.log("Car started.");
  }
  stop(): void {
    console.log("Car stopped.");
  }
}

let myCar = new Car();
myCar.start(); // 输出:"Car started."

3. 既继承类又实现接口

在 ArkTS 中,类可以继承其他类并实现多个接口,这使得类可以在继承的基础上进一步扩展功能。以下示例展示了 ElectricCar 类如何继承 Vehicle 类的基础属性和方法,同时实现 Rechargeable 接口,增加了新的行为:

interface Rechargeable {
  recharge(): void;
}

class Vehicle {
  fuelLevel: number = 100;
  drive(): void {
    console.log("Vehicle is driving.");
  }
}

class ElectricCar extends Vehicle implements Drivable, Rechargeable {
  start(): void {
    console.log("Electric car started.");
  }
  stop(): void {
    console.log("Electric car stopped.");
  }
  recharge(): void {
    console.log("Electric car is recharging.");
  }
}

let myElectricCar = new ElectricCar();
myElectricCar.start();       // 输出:"Electric car started."
myElectricCar.drive();        // 输出:"Vehicle is driving."
myElectricCar.recharge();     // 输出:"Electric car is recharging."

4. 多重实现

一个类可以实现多个接口,但 ArkTS 中类不支持多重继承(即一个类不能继承多个类)。例如,以下代码展示了一个 Airplane 类,同时实现了 Drivable 和 Flyable 接口:

interface Flyable {
  takeOff(): void;
  land(): void;
}

class Airplane implements Drivable, Flyable {
  start(): void {
    console.log("Airplane engines started.");
  }
  stop(): void {
    console.log("Airplane engines stopped.");
  }
  takeOff(): void {
    console.log("Airplane is taking off.");
  }
  land(): void {
    console.log("Airplane is landing.");
  }
}

let myPlane = new Airplane();
myPlane.start(); // 输出:"Airplane engines started."
myPlane.takeOff(); // 输出:"Airplane is taking off."

5. 接口、类、继承和实现的关系

接口、类、继承和实现的关系可以总结如下:

  • 接口(Interface):定义一组属性和方法,不提供具体实现,作为类的结构约束。
  • 类(Class):定义对象的属性和行为,描述其状态和方法。
  • 继承(Inheritance):类可以继承另一个类的属性和方法,但 ArkTS 中一个类只能继承一个父类。
  • 实现(Implements):类可以实现一个或多个接口,必须提供接口中所有属性和方法的具体实现。

6. 使用接口约束类行为

接口还可以用于约束函数参数类型或返回类型。例如,如果一个函数的参数必须符合某个接口结构,我们可以这样使用接口:

interface Logger {
  log(message: string): void;
}

function performLogging(logger: Logger) {
  logger.log("This is a log message");
}

class ConsoleLogger implements Logger {
  log(message: string): void {
    console.log(message);
  }
}

let logger = new ConsoleLogger();
performLogging(logger); // 输出:"This is a log message"

在 performLogging 函数中,logger 参数必须符合 Logger 接口,保证了函数的类型安全性和可维护性。

7. 总结

  • 接口为类提供了行为契约,约定了类必须实现的属性和方法。
  • 继承用于复用已有的类结构,使得子类能够继承父类的属性和方法。
  • 实现使类可以扩展多个接口的功能,但类只能继承一个父类。

通过合理利用接口、继承和实现,我们可以在 ArkTS 中构建结构良好、易于维护的代码。


十: 泛型类型和函数

泛型(Generic)允许创建在各种类型上运行的代码,而不仅限于单一类型。这可以提高代码的复用性和类型安全性,特别适用于处理集合或其他复杂数据类型。

1 泛型类和接口

类和接口可以使用泛型参数来定义,以便在实例化时指定具体的类型。下面是一个定义了泛型参数 Element 的示例类 CustomStack:

class CustomStack<Element> {
  private items: Element[] = [];
  
  public push(e: Element): void {
    this.items.push(e);
  }
  
  public pop(): Element | undefined {
    return this.items.pop();
  }
}

使用泛型类时,必须为类型参数提供实际类型:

let stack = new CustomStack<string>();
stack.push('hello');
// stack.push(55); // 编译时错误,类型不匹配

2 泛型约束

可以为泛型参数添加约束,以确保该参数符合特定的接口。例如,下面的 MyHashMap 类限制 Key 类型必须实现 Hashable 接口,确保调用 hash() 方法不会出错:

interface Hashable {
  hash(): number;
}

class MyHashMap<Key extends Hashable, Value> {
  private map = new Map<number, Value>();
  
  public set(k: Key, v: Value): void {
    this.map.set(k.hash(), v);
  }
}

在这个例子中,Key 类型必须具有 hash 方法,编译器将会验证传入的类型是否满足这一条件。

3 泛型函数

函数也可以定义为泛型,以处理不同类型的数据。例如,下面的 last 函数可以返回数组的最后一个元素,而不限定数组的元素类型:

function last<T>(items: T[]): T {
  return items[items.length - 1];
}

last([1, 2, 3]);            // 返回 3
last(['a', 'b', 'c']);      // 返回 'c'

调用泛型函数时,类型参数可以显式或隐式指定:

// 显式指定类型参数
last<string>(['apple', 'banana']);
last<number>([10, 20, 30]);

// 隐式推断类型参数
last([true, false, true]);

4 泛型默认值

在泛型中可以为类型参数设置默认值,如果未提供实际类型实参,则使用默认类型:

class Box<T = string> {
  contents: T;
  constructor(value: T) {
    this.contents = value;
  }
}

let box1 = new Box<number>(42); // T 为 number
let box2 = new Box();           // T 使用默认类型 string

对于函数,泛型参数的默认值同样可用:

function createArray<T = number>(length: number, value: T): T[] {
  return Array(length).fill(value);
}

createArray(3, 'hello'); // 返回 ['hello', 'hello', 'hello']
createArray(3, 42);      // 返回 [42, 42, 42]

泛型默认值提高了泛型的灵活性,让代码适配更多场景。


十一:模块和导入导出

在 ArkTS 中,程序可以划分为多个模块。模块为每个部分提供独立的作用域,模块中的声明在其他模块中不可见,除非显式导出。通过导入,其他模块可以访问导出的内容。以下为模块的基础用法,包括导出和导入的多种形式。

1. 导出

可以使用 export 关键字导出模块内的顶层声明。导出后,声明名称可以在其他模块中导入和使用。未导出的声明在模块外部不可见。

// point.ts
export class Point {
  x: number = 0;
  y: number = 0;
  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }
}

export let Origin = new Point(0, 0);

export function Distance(p1: Point, p2: Point): number {
  return Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2);
}
2. 静态导入

在其他模块中,使用 import 关键字导入需要的内容:

// main.ts
import { Point, Origin, Distance } from './point';

let p1 = new Point(3, 4);
console.log(Distance(Origin, p1)); // 输出:5
3. 导入绑定

可以使用不同的导入形式以灵活地绑定导出内容。

  • 导入全部:import * as Utils 导入模块所有内容,并通过 Utils 引用。

    import * as Utils from './point';
    console.log(Utils.Origin);
    
  • 选择性导入:import { X, Y } 仅导入特定内容。

    import { Origin, Distance } from './point';
    
  • 重命名导入:可以为导入的内容定义别名,避免命名冲突。

    import { Distance as CalculateDistance } from './point';
    
4. 动态导入

动态导入允许按需加载模块,这种方式更适合条件导入或延迟加载的场景。import() 会返回一个 Promise。

async function testDynamicImport() {
  let module = await import('./say');
  module.hi();
  module.bye();
}
5. HarmonyOS SDK的开放能力导入

在 HarmonyOS 开发中,SDK 提供的开放能力(接口)可通过导入 SDK 模块来使用。HarmonyOS 引入了 Kit 概念以便开发者调用所需的接口模块。

  • 导入 Kit 单个模块:import { UIAbility } from '@kit.AbilityKit';
  • 导入 Kit 多个模块:import { UIAbility, Ability } from '@kit.AbilityKit';
  • 导入 Kit 全部模块:import * as module from '@kit.AbilityKit';(慎用,避免导入无用模块)
6. 顶层语句

顶层语句指的是不包裹在函数、类或块级作用域中的模块最外层语句,通常包括变量声明、函数声明等。

// 顶层变量
let topLevelVariable = 'Hello';
// 顶层函数
function topLevelFunction() {
  console.log(topLevelVariable);
}

模块化使程序更易于维护和调试,同时提高代码的复用性与安全性。在 HarmonyOS SDK 中,合理使用静态导入和动态导入能够优化资源占用,避免包体积过大。

【HarmonyOS NEXT开发】鸿蒙开发环境准备,ArkTS基础语法入门 阅读详情

相关推荐

华为鸿蒙HarmonyOS Next基础开发教程

《HarmonyOSNext开发指南》摘要: HarmonyOSNext是华为2025年推出的纯自研分布式操作系统,完全脱离安卓生态,采用ArkTS语言和微内核架构,具备原生精致、流畅、安全等六大特性。本文系统介绍了开发环境搭建(DevEcoStudio+SDK)、ArkTS语言基础(静态类型检查/声明式UI)、UI开发框架(声明式布局/组件化)、状态管理机制(@State/@Link等装饰器)、本地存储(Preferences)和网络请求(http模块)等核心内容,并包含调试技巧与发布流程。通过60天学习

abcdlwt的博客 1973

HarmonyOS开发:ArkTs常见数据类型(一)

本文针对开发中常用的数据类型,做一个简单的概述,便于第一次接触到ArkTs语言开发的同学,能够快速的对数据类型做一个了解。

知足常乐 4045

鸿蒙Harmony应用开发—ArkTS声明式开发(基础手势:LoadingProgress)

ArkTS声明式开发(基础手势:LoadingProgress)

m0_64420071的博客 1644

ArkTs基础语法

b(1, 2, a)与函数类型结合使用,演进为c(1, 2, a)进而演进,形成我们经常使用的回调函数})

gitzzp的博客 1665

HarmonyOS鸿蒙开发-ArkTS初学01

申明:文章所有内容均来自于【哔哩哔哩-黑马程序员鸿蒙HarmonyOS NEXT星河版零基础入门到实战,零基础也能快速入门鸿蒙开发教程】本文是学习后的复盘,若有错漏,敬请各位大佬指正!!小包拜谢各位大佬!!!

weixin_52851384的博客 1610

HarmonyOS 开发:ArkTS 语言基础入门

基本概述: 在鸿蒙开发早期使用JavaScript 配合Fage 模型,而如今更为推荐ArkTS 语言 + Stage 模型,这跟Android 开发很相近。早期Android 使用Java 语言配合第三方框架,现Kotlin + JetPack 框架逐渐占据主流地位。ArkTS 语言基础是我们走进HarmonyOS 开发的第一课显。 文章以ArkTS 语言为主题,通过文字 + Demo 的形式,简略介绍了鸿蒙开发前期所需的ArkTS 语言基础。 ArkTS 是在TypeScript 的基础上加上鸿蒙特性,

m0_70749039的博客 1806

ArkTs

TS

weixin_64443786的博客 3117

鸿蒙HarmonyOS NEXT开发之路 卷1:ArkTS语言篇

在数字化浪潮的推动下,全球科技领域正经历着前所未有的变革。我国作为这一变革的积极参与者,不仅在多个科技前沿领域取得了显著成就,更在计算机操作系统这一核心技术领域孕育出了具有自主知识产权的创新成果—鸿蒙系统(HarmonyOS)。这一系统开发成功不仅是国人的骄傲,更是全球技术竞争中的一股新兴力量。鸿蒙系统的诞生,标志着我国在全球操作系统领域迈出了坚实的一步。凭借其独特的分布式架构、跨平台能力以及对开发者友好的设计理念,它为智能设备带来了全新的使用体验。

颜颜yan_的博客 1122

鸿蒙ArkTS语言快速入门-TS(三)

TS 入门之函数的用法

shenfei平凡之路 2072

华为鸿蒙HarmonyOS Next鸿蒙开发教程

HarmonyOSNext是华为新一代分布式操作系统,具有原生应用生态、增强分布式能力、开发效率提升等优势。本指南从开发环境搭建开始,详细介绍了HarmonyOSNext的核心架构、应用模型、ArkTS语言基础,以及UI开发、状态管理、数据存储等关键技术。特别强调了分布式应用开发流程,包括设备发现、能力共享等特色功能。最后讲解了应用测试与发布流程,并提供了学习路径建议。教程适合零基础和有经验的开发者,通过系统学习和实践,能够掌握HarmonyOSNext开发的核心技能。随着鸿蒙生态的快速发展,掌握这些技术将

2501_93196080的博客 1341

MCNP 减方差技巧(最全)

MCNP的减方差技巧,核心在于不显著增加计算时间的前提下,通过修改模拟过程来降低结果的统计误差。尤其适用于,这类问题中粒子很难到达探测器区域,直接模拟效率极低栅元重要性是常用的减方差技巧,该方法主要对计算模型的不同区域定义不同的重要性数值。当粒子从重要性低的区域废物重要性高的区域,产生更多粒子,增大统计量;当从重要性高的区域进入重要性低的区域,会进行,增快计算效率。n= 中子,N;光子,P;电子 Exi= 栅元i的重要性I=栅元总数项目IMP卡是必须的,除非使用了WWN卡如果粒子进入0。

chencheng1127的博客 935

【粉丝福利社】鸿蒙HarmonyOS NEXT开发之路 卷1:ArkTS语言篇

在数字化浪潮的推动下,全球科技领域正经历着前所未有的变革。我国作为这一变革的积极参与者,不仅在多个科技前沿领域取得了显著成就,更在计算机操作系统这一核心技术领域孕育出了具有自主知识产权的创新成果—鸿蒙系统(HarmonyOS)。这一系统开发成功不仅是国人的骄傲,更是全球技术竞争中的一股新兴力量。鸿蒙系统的诞生,标志着我国在全球操作系统领域迈出了坚实的一步。凭借其独特的分布式架构、跨平台能力以及对开发者友好的设计理念,它为智能设备带来了全新的使用体验。

愚公智库 10万+

香橙派OPi 6系列选型指南:RK3588与RK3588S开发板深度对比

开发板选型是嵌入式系统设计的关键环节,尤其在边缘计算和AI推理等场景中,芯片的差异直接影响硬件架构。瑞芯微RK3588及其精简版RK3588S是当前高端开发板的核心方案,两者在PCIe通道、显示输出和SATA支持上存在显著区别。理解这些原理,有助于工程师根据项目需求快速匹配产品。香橙派OPi 6系列基于这两款芯片,衍生出OPi 6、OPi 6 Pro与OPi 6 Max三种形态:紧凑型适合嵌入式门禁与AI盒子,Pro版凭借双屏异显和PCIe 3.0满足收银机与视频分析,Max的双2.5G网口和大内存则面向轻

weixin_29185167的博客 231

0 基础入门鸿蒙:跟着《HarmonyOS 第一课》1 周掌握应用开发核心能力

这篇文章介绍了《HarmonyOS 第一课》课程的完整学习路径和体验感受,适合零基础开发者入门鸿蒙开发。主要内容包括: 课程分为基础、中级、高级三阶段,共24门课,涵盖从环境搭建到应用上架的全流程 基础阶段学习ArkTS语言和ArkUI框架,中级阶段掌握复杂功能开发,高级阶段学习跨设备协同等鸿蒙特色能力 课程优势:全链路覆盖、80%实战内容、紧跟鸿蒙最新特性,并提供配套资源和答疑支持 给零基础学习者的建议:保持每天1-2小时学习节奏,边学边改代码,善用调试工具解决问题 文章通过作者亲身体验,展示了如何从零开

科技改变人类,技术成就未来 3万+

告别社区5级:一个脚本搞定小米/红米BL解锁的账号绑定限制(附资源下载与避坑指南)

本文提供了一种绕过小米/红米设备Bootloader解锁社区等级限制的技术方案,适用于MIUI 12.5-14和HyperOS 1.0系统。通过自动化脚本临时修改系统组件,用户可快速完成账号绑定和设备解锁流程,附详细操作指南和常见问题解决方案。

weixin_27330481的博客 741

MODBUS通讯不求人:手把手教你用三菱FX2N控制士林变频器

本文详细介绍了如何使用三菱FX2N PLC通过MODBUS协议控制士林变频器,涵盖硬件连接、参数配置、程序设计及通讯优化等关键步骤。特别针对没有内置MODBUS函数块的老款PLC,提供了CRC校验和稳定数据交换的实用解决方案,帮助工程师快速实现工业自动化设备的高效通讯。

v4w5x6的博客 227

【HarmonyOS鸿蒙开发技术】鸿蒙系统(HarmonyOS)鸿蒙开发入门篇

本文系统介绍了鸿蒙操作系统(HarmonyOS)开发技术体系。鸿蒙作为面向全场景的分布式操作系统,其核心技术包括分布式计算、声明式UI、跨设备协同等。文章从五个层次详细解析了鸿蒙开发技术:内核与系统服务层、应用框架层、开发语言层、开发工具链和生态能力层。重点阐述了应用开发核心技术(Ability组件、状态管理、UI开发等)、系统能力调用(服务访问、设备能力调用)以及开发工具链(DevEcoStudio等)。文章还提供了从入门到精通的技术学习路径规划,帮助开发者建立完整的鸿蒙开发技术体系认知,为开发全场景智能

2501_93196106的博客 2688

AI智能体面试实战与真题解析: 312+道面试题完整答案 (下篇)

本文覆盖220道基础八股文+92道项目面试题,涵盖Agent架构、RAG、工具调用、记忆系统、多智能体、大模型基础、工程化实践、Prompt工程9大模块,含完整代码实现和模拟面试剧本。

program哲学 313

HarmonyOS-鸿蒙系统概述

华为“1+8+N” 全场景智慧战略,其中居于核心的“1”是智能手机,“8”是指围绕手机的车机、音箱、耳机、手表/手环、平板、大屏、PC、AR/VR产品,N则指众多泛IoT设备。

Hidanchaofan的博客 3511

AI 实战篇 |基于 AI开放平台实现 人脸识别对比 功能,超详细教程【附带源码】

本篇文章来学习一下怎样使用 Unity实现简单地人脸识别 功能。 关于人脸识别,我们可以选择很多平台的SDK接入Unity来实现人脸识别的功能。

努力前行,总会成为自己心中的那道光 5万+

智驾车载以太网(18)-switch之报文转发和vlan处理流程

本文详细解析了交换机中报文处理和转发流程:1)通过目标MAC查找转发端口,源MAC创建ARL条目;2)VLAN标签处理包括tagged/untagged帧判断、默认VID标记等5种处理方式;3)完整转发流程包含CRC校验、IQ封装、VLAN和ARL表查询、端口向量计算及优先级队列发送。文中还涉及TCAM修改VLAN、802.1q多种模式处理等细节,省略了流量控制等次要流程。该过程实现了基于MAC和VLAN的高效二层交换。

mitugaoyang1993的博客 44

你了解鸿蒙吗?鸿蒙系统和安卓系统的区别在哪里?

在鸿蒙系统之前,我们一直使用的都是安卓系统,那么此时就有小伙伴会问了,新发布的鸿蒙系统和安卓的区别在哪里呢相信这也是很多使用安卓手机的小伙伴们最好奇的地方了吧。自正式亮相至今,鸿蒙系统已经在极短的时间内获得了超2亿的用户数量,是全球用户增长速度最快的移动操作系统。无论是学校还是在社会上,鸿蒙的学习也迎来了热潮。那么现在就算我们学习鸿蒙的最好的时候, 考虑到市场上还没有系统的入门资料,所以就整理了一份《鸿蒙零基础入门学习指南》,希望能对那些想要学习鸿蒙,但是有没有方向的人提供一点帮助。

bugyinyin的博客 2564

MuJoCo XLA (MJX) 强化学习人形机器人四足机器人入门教程(三)

MJX 是用 JAX 编写的 MuJoCo 实现,可以在 GPU/TPU 上进行大批量训练。在本笔记本中,我们将演示如何使用 MJX 训练 RL 策略。在开始大量 RL 工作负载之前,我们先从一个简单的示例开始!xml = """"""接下来,我们使用 MJX 将 MuJoCo 模型和数据放到 GPU 设备上。下面,我们将打印来自 MuJoCo 和 MJX 的 qpos。

2506_90492529的博客 2474

鸿蒙应用开发小白入门推荐书籍—《ArkTS鸿蒙应用开发入门到实战》

鸿蒙应用开发是指在华为鸿蒙操作系统(HarmonyOS)上进行应用程序开发的过程。鸿蒙操作系统是华为推出的一款全新的操作系统,旨在为不同类型的设备提供统一、智能、流畅的操作体验。与传统的安卓或iOS操作系统不同,鸿蒙系统采用了分布式技术,能够跨设备、跨平台进行无缝连接,覆盖智能手机、智能电视、智能穿戴设备、汽车等多个终端。鸿蒙应用开发主要是基于ArkTS(HarmonyOS的开发语言)和ArkUI框架来开发应用程序。开发者可以通过使用这些工具和技术,创建适用于各种终端设备的高性能应用。

2401_82857325的博客 1093

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

HarmonyOS鸿蒙开发入门 , ArkTS语言的了解

鸿蒙(即HarmonyOS,开发代号Ark,正式名称为华为终端鸿蒙智能设备操作系统软件)是由华为公司2012年以来开发的分布式操作系统,并于2019年8月正式发布。该系统利用“分布式”技术,将手机、电脑、平板、电视、汽车和智能穿戴等多款设备融合成一个“超级终端”,使用户便于操作和共享各种设备的资源。通过这篇博客,我会记录我在学习HarmonyOS语法遇到的重点和难点。

WDJ54068923的博客 1万+

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

HarmonyOS鸿蒙开发-ArkTS

本文系统介绍了华为自主研发的ArkTS语言,作为HarmonyOS开发的核心编程语言。文章从ArkTS的价值定位、TypeScript基础对比、装饰器体系、响应式编程到高级特性展开,重点讲解了其声明式UI、状态管理等核心功能。ArkTS在TypeScript基础上扩展了鸿蒙特性,通过静态类型检查和装饰器机制简化复杂应用开发。文章还提供了代码组织、性能优化等实践建议,并展望了ArkTS在全场景智能时代的未来发展潜力。掌握ArkTS不仅能开发鸿蒙应用,更能提升编程素养,适应多终端融合的开发趋势。

2501_93207838的博客 2206

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

上一篇: 【鸿蒙开发入门:ArkTS 基础(上篇)】
coderzach
博客等级 码龄10年 87粉丝 11原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值