【鸿蒙开发入门: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

【GAMES101】现代计算机图形学入门 资料整理

课程网址 课程主页 包括ppt 课程PPT和视频 一篇搞定!GAMES101现代计算机图形学入门(全) 作业链接地址 作业论坛 GAMES101课程环境搭建(Win10+VSCode) 计算机图形学笔记 虎书pdf 提取:n2rx 【必须】:高等数学(微积分、线性代数)、算法、数据结构 【非必须】:信号处理、数值分析、大学物理(光学) 在线公式编辑器 一定要做作业,如果个人要配置环境的话应该是配置opencv,eigen这两个核心库就行了,目前觉得最核心的一个作业是作业3,实现着色器和渲染管线,做完一遍

ysh的博客 2687

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

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

愚公智库 10万+

华为海思2026届数字IC秋招笔试真题解析与实战技巧(2025最新版)

本文深度解析华为海思2026届数字IC秋招笔试真题,涵盖高频考点如后端设计、低功耗设计、SystemVerilog语法等核心内容。提供时序违例修复、时钟树综合等实战技巧,帮助考生高效备考。特别关注UPF低功耗设计规范等最新考点,助力考生在秋招笔试中脱颖而出。

lg888的博客 1092

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

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

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

如何使用C#自带的GDI+双缓冲类BufferedGraphics实现双缓冲功能

小白摸索着编写一个上位机界面,将遇到的问题及解决方法记录下,以供后来的小白使用哈。这篇文章解决的问题是在绘图时候的闪烁问题。其中网上有些介绍的设置控制方式controlstyle的方法,这个方法我的理解是比较适合于在一个完整的窗口当中绘图。如果要在一个窗口当中的内部容器或者控件内画图的话就不太适合,通常按照前述的方法设置后没有任何效果。对于在窗口内部的绘图的来说,比较有效的方法是在内存当中开辟一块

z20110411的博客 4797

Vast.ai GPU服务器租用与SSH密钥连接实战指南

本文详细介绍了如何在Vast.ai平台租用GPU服务器并通过SSH密钥安全连接的全流程。从注册、选配GPU型号到SSH密钥生成与配置,再到实战中的端口转发和文件传输技巧,帮助用户高效利用云端GPU资源进行深度学习等计算密集型任务。

weixin_29574585的博客 533

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

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

2501_93196106的博客 2687

《企业AI能力地图构建:AI应用架构师的关键秘籍》

构建企业AI能力地图是企业在AI时代实现战略转型和创新发展的关键举措,它需要从评估企业当前AI能力出发,全面了解技术储备、数据资产和人才队伍的现状。将企业业务战略转化为具体的AI应用场景,并进行优先级排序,是确保AI应用能够为企业带来实际价值的重要步骤。通过深入理解业务战略和挖掘应用场景,企业可以找准AI应用的切入点,提高投资回报率。

AI架构全栈开发实战笔记 634

HarmonyOS-鸿蒙系统概述

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

Hidanchaofan的博客 3510

绿米Aqara S1【妙控开关 S1E】版本降级或升级自定义固件的方法

绿米Aqara S1【妙控开关 S1E】版本降级或升级自定义固件的方法

LeeKwen的专栏 2189

025、空间降噪与时域降噪:噪声抑制与细节保留的平衡艺术

《降噪技术的平衡艺术:空间与时域降噪的协同优化》 本文深入探讨了图像处理中空间降噪与时域降噪的技术原理与工程实践。空间降噪通过像素级处理提升单帧质量,而时域降噪则利用帧间信息增强稳定性。文章揭示了两种方法在实际应用中的矛盾点:过度降噪会导致细节损失,影响后续算法性能。作者结合车载环视系统等实战案例,详细分享了参数调优经验,包括运动自适应策略、边缘保持技巧和嵌入式平台优化方案。特别强调降噪的最终目标应服务于下游算法需求,而非单纯追求图像美观。文章为工程人员提供了从理论到实践的完整指导,展现了降噪技术在效果与性

sundong_81的博客 189

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

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

bugyinyin的博客 2564

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

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

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

2401_82857325的博客 1093

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

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

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

WDJ54068923的博客 1万+

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

HarmonyOS鸿蒙开发-ArkTS

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值