目前流行的编程语言TypeScript是在JavaScript基础上通过添加类型定义扩展而来的,而ArkTS则是TypeScript的进一步扩展。

TypeScript深受开发者的喜爱,因为它提供了一种更结构化的JavaScript编码方法。

ArkTS旨在保持TypeScript的大部分语法,为现有的TypeScript开发者实现无缝过渡,让移动开发者快速上手ArlTS

 

基本知识 

声明

变量声明

let hi: string = 'hello';
hi = 'hello, world';

以关键字let的声明引入变量hi，: string表示变量类型

常量声明 

const hello: string = 'hello';

 自动类型判断

let hi1: string = 'hello';
let hi2 = 'hello, world';

 若一常量或变量的声明已包含初始值，则不需要显示指示其类型

 

类型

 

number类型

任何浮点数或整数都可以被赋值给此类型的变量

整数字面量

由数字序列组成的十进制整数。例如:0、117、-345
以0x(或0X)开头的十六进制整数。例如:0x1123、0x00111、-0xF1A7
以0o(或00)开头的八进制整数。例如:00777
以0b(或0B)开头的二进制整数。例如:0b11、0b0011、-0b11

浮点数字面量

十进制整数,可为有符号数(即,前缀为"+"或"-")
小数点(".")
小数部分(由十进制数字字符串表示)
以"e"或"E"开头的指数部分,后跟有符号(即,前缀为"+"或"-")或无符号整数

实例

let n1 = 3.14;
let n2 = 3.141592;
let n3 = .5;
let n4 = 1e2;

function factorial(n: number): number {
  if (n <= 1) {
    return 1;
  }
  return n * factorial(n - 1);
}

factorial(n1)  //  7.660344000000002 
factorial(n2)  //  7.680640444893748 
factorial(n3)  //  1 
factorial(n4)  //  9.33262154439441e+157 

注意

number类型能表示的数字大小有限，当数字特别大时会造成精度缺失，开发中按需使用bigint类型来确保精度。

let BidInter: BidInt = BigInt ('99999999999999999999999999999999999999');
console.log ('BigInter' + BigInter.toString ());

第一行
通过BigInt()函数将这个非常大的数转变为BigInt类型
第二行
console.log表示输出
' '表示字符串，.toString表示将BigInter的值转化为字符串
输出结果
BigIner99999999999999999999999 

 

boolean类型

就是布尔类型

let isDone: boolean = false;
//...
if (isDone) {
  console.log ('Done!');
}

string类型

可以使用C语言中的转义字符（/t,/n等）

字符串字面量由单引号（'）或双引号（"）之间括起来去的字符组成。但是，还有一种特殊形式，是用反向单引号（`）括起来的模板字面量。

let s1 = 'hello world';
let s2 = 'hello world\n';
let s3 = `helo ${a}`;//表示插入变量a
//会把a的属性值嵌入到字符串中

void类型

用法和C语言类似

此类型只有一个值，同样是void。由于void是引用类型，因此它可以用于泛型类型参数

class Class<T> {
  //...
}
let instance:Class <void>

类是怎么用，做什么的用到再说 

object类型

表示出基本类型意外的类型，是所有引用类型的基类型。任何值及基本类型都可以被自动装箱被赋值给object类型的变量。

arry类型

数组，类似C语言的数组

let names: string[] = ['Alice', 'Bob', 'Carol'];

enum类型

C语言中也有枚举类型

使用枚举常量时必须以枚举类型名称为前缀

enum ColorSet { Red, Green, Blue }
let c: ColorSet = ColorSet.Blue;

可以显示设置枚举常量的值 

enum ColorSet { White = 0xFF, Grey = 0x7F, Black = 0x00 }
let c: ColorSet = ColorSet.Black;

union类型

C语言中也可以使用联合

这里用  |  来分隔不同的类型

//变量可以是 string 或 number 类型
let value: string | number;
value = "Hello,ArkTS!";
console,log(value);
value = 123;
console.log(value);

Aliases 类型

这里用  type  。

感觉像C++中的  typedef  。

//简单类型别名
type Matrix = number[][];
//联合类型别名
type NullableObject = Object | null;
//对象类型别名
type Person = {
    name: string;
    age: number;
};

// 定义自定义类型
type Person = {
    name: string;
    age: number;
};

type Animal = {
    species: string;
    legs: number;
};


type Entity = Person | Animal;


function describeEntity(entity: Entity) {
    if ('name' in entity) {
        console.log(`This is a person named ${entity.name}, aged ${entity.age}.`);
    } else {
        console.log(`This is an animal of species ${entity.species} with ${entity.legs} legs.`);
    }
}

// 创建 Person 实例并调用函数
const person: Person = { name: 'Alice', age: 30 };
describeEntity(person);

// 创建 Animal 实例并调用函数
const animal: Animal = { species: 'Dog', legs: 4 };
describeEntity(animal);

 

运算符 

与C语言基本一致，不再介绍

位运算符

a&b	位与
a^b	位或
a|b	位异或
a<<b	左移，a的2进制向左b位
a>>b	算术右移
a>>>b	逻辑右移
~a	位非

 “==”和“===”不同，“===”是更严格的相等不仅比较值是否相等，还比较数据类型是否相等。而“==”比较值是否相等，并在必要时进行数据类型的转换。#（只会C语言的我表示很惊讶#）

与之对应的是"!="和"!=="。

语句

 

if语句

for语句

switch语句

break语句

continue语句

while和do-while语句

条件语句

condition ? expression1 : expression2

例如C语言中的三目运算 

 

均与C语言基本一致这里详细介绍一下throw-try语句和for-of语句

for-of语句

常用于遍历数组和字符串

举例 

遍历数组

这个是从官方抄的的： 

for (forVar of expression) {
  statements
}

看这个吧，比官方通俗一点 

const array = [1,2,3,4];
for (let element of array){
    element = element*2;
    console.log(element);
}
console.log(array);

      

 我发现这个console.log()不像C语言的printf()那样麻烦，可以直接把数组输出出来。

在查资料时发现“===”这个符号！

“==”和“===”不同，“===”是更严格的相等不仅比较值是否相等，还比较数据类型是否相等。而“==”比较值是否相等，并在必要时进行数据类型的转换。#（只会C语言的我表示很惊讶#）

遍历字符串

ArkTS中并没有char类型。所以......我不清楚🤷‍♀️，大概string类型也像number类型那样可以包含多种吧😂。

官方文档是这样的：

for (let ch of 'a string object') {
  /* process ch */
}

注意

上面所举得遍历数组例子中||由于let的块级作用域特性，原始数据不会被修改 ！

据说，可以这样修改：#（javascript是这样的╮(╯▽╰)╭）

const array = [1,2,3,4,5];
let i = 0;
for (const element of array) {
    //通过索引修改数组元素
    array[i] = element * 2;
    i++;
}
console.log(array);

throw和try语句

thow常用于抛出异常和错误。

而tap则用于捕获和处理异常错误。

class ZeroDivisor extends Error {}

function divide (a: number, b: number): number{
  if (b == 0) throw new ZeroDivisor();
  return a / b;
}

function process (a: number, b: number) {
  try {
    let res = divide(a, b);
    console.log('result: ' + res);
  } catch (x) {
    console.log('some error');
  }
}

不会类的看这个

function validateAge(age: number) {
    if (age < 0 ||age > 150){
       // 主动抛出异常
       throw new Error('年龄必须在0到150之间');
    }
    console.log('年龄有效');
}
try{
   // 调用可能抛出异常的函数
   validateAge(-5);
} catch (error){
    //捕获异常并处理
    console.log('发生错误：',error.message);

 官方说他也支持finally语句，但是🤔，什么是finally语句？

function processData(s: string) {
  let error: Error | null = null;

  try {
    console.log('Data processed: ' + s);
    // ...
    // 可能发生异常的语句
    // ...
  } catch (e) {
    error = e as Error;
    // ...
    // 异常处理
    // ...
  } finally {
    if (error != null) {
      console.log(`Error caught: input='${s}', message='${error.message}'`);
    }
  }
}

先从官网粘下来，学到了再看 吧

函数

函数声明

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

${}的作用能get到吧

声明时，需为每个参数标记类型。但是如果是可选参数，可在调用函数时省略该参数。并且，允许最后一个参数是rest参数。

可选参数

个人感觉这个东西挺好

function  hello(name?: string) {
  if (name == undefined) {
     console.log('Hello！');
   } else {
     consloe.log('Hello,${name}!');
   }
}

可选参数还可以设置默认参数

#（怪不得有人吐槽C语言老旧了） 

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

Rest参数

使用rest参数时，允许函数或方法接受任意数量的实参。#（还不知道方法是什么）

类（Class）中的函数可以称之为方法

 

 例如，可以传入n个数组成数组

sum(); // 返回0
sum(1, 2, 3); // 返回6
function sum(...numbers: number[]): number {
  let res = 0;
  for (let n of numbers)
    res += n;
  return res;
}

返回类型

如果可以根据return语句推断出反回类型，则在声明时可以省略标注返回值类型

显式指定反会类型

function foo(): string {
  return 'foo';
}

隐式返回类型

function goo() {
  return 'goo';
}

void返回类型 

同C语言，只是C语言在前面声明。

并且，因为无return语句，是可以推断的，所以可省略标注。

function hi1() {
  console.log('hi');
}

function hi2(): void {
  console.log('hi');
}

函数的作用域

同C语言

函数的调用

同C语言

函数的类型

函数类型通常用于回调

回调经常看到，但还不太清楚

type trigFunc = (x: number) => number // 这是一个函数类型

function do_action(f: trigFunc) {
  f(3.141592653589); // 调用函数
}

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

箭头函数（Lambda）

因为是特别常见的，所以在这里多做一点笔记。

const calculate = (a: number, b: number) => {
    const sum = a + b;
    const product = a * b;
    return { sum, product };
};

省略 

如果只有一个参数，括号可以省略；如果函数体只有一条语句，花括号和return都可以省略

let sum = (x: number, y: number): number => {
  return x + y;
}

 可省略为：

let sum = (x: number, y: number) => x + y;

 因为是特别常见的，所以在这里多做一点笔记。

无参数类型

const sayHello = () => console.log('Hello, ArkTS!');

闭包

闭包引用了外部函数的变量，这些变量不会随着外部函数的执行结束而被销毁，从而可以在后续的操作中继续使用这些变量的值。C语言中可不是这样的！

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

let z = f();
z(); // 返回：1
z(); // 返回：2

C语言中可以使用全局变量来模拟闭包。 而C++还可以使用Lambda表达式实现闭包

函数重载

function foo(x: number): void;
function foo(x: string): void;
function foo(x: number | string): void {
    if (typeof x === 'number') {
        console.log(`Received a number: ${x}`);
    } else {
        console.log(`Received a string: ${x}`);
    }
}

foo(123); 
foo('hello'); 

C语言没有，但C++有  

有点像联合union

注意：前面两个函数的定义是不可以省略的。

类，对象，方法等见下期