HarmonyOS开发学习笔记

JS基础语法

        let 修饰变量

        const 修饰常亮

        在 JavaScript 中有 8 种基本的数据类型（译注：7 种原始类型和 1 种引用类型）。

Number 类型  

number 类型代表整数和浮点数。

数字可以有很多操作，比如，乘法 *、除法 /、加法 +、减法 - 等等。

除了常规的数字，还包括所谓的“特殊数值（“special numeric values”）”也属于这种类型：Infinity、-Infinity 和 NaN。

• Infinity 代表数学概念中的 无穷大 ∞。是一个比任何数字都大的特殊值。

  我们可以通过除以 0 来得到它：

  alert(1/0);// Infinity

  或者在代码中直接使用它：

  alert(Infinity);// Infinity

• NaN 代表一个计算错误。它是一个不正确的或者一个未定义的数学操作所得到的结果，比如：

  alert("not a number"/2);// NaN，这样的除法是错误的

  NaN 是粘性的。任何对 NaN 的进一步数学运算都会返回 NaN：

  alert(NaN+ 1); // NaN
  alert(3*NaN); // NaN
  alert("not a number"/2-1);// NaN

  所以，如果在数学表达式中有一个 NaN，会被传播到最终结果（只有一个例外：NaN ** 0 结果为 1）。

 BigInt类型

        BigInt 类型是最近被添加到 JavaScript 语言中的，用于表示任意长度的整数。

可以通过将 n 附加到整数字段的末尾来创建 BigInt 值。

// 尾部的 "n" 表示这是一个 BigInt 类型constbigInt =234567890123456789012345678901234567890n;

 String类型

JavaScript 中的字符串必须被括在引号里。

let str = "Hello";let str2 ='Single quotes are ok too';let phrase =`can embed another ${str}`;

在 JavaScript 中，有三种包含字符串的方式。

1. 双引号："Hello".
2. 单引号：'Hello'.
3. 反引号：`Hello`.

双引号和单引号都是“简单”引用，在 JavaScript 中两者几乎没有什么差别。

反引号是 功能扩展 引号。它们允许我们通过将变量和表达式包装在 ${…} 中，来将它们嵌入到字符串中。例如：

let name ="John";// 嵌入一个变量alert(`Hello, ${name}!`);// Hello, John!// 嵌入一个表达式alert(`the result is ${1+2}` ); // the result is 3

${…} 内的表达式会被计算，计算结果会成为字符串的一部分。可以在 ${…} 内放置任何东西：诸如名为 name 的变量，或者诸如 1 + 2 的算数表达式，或者其他一些更复杂的。

需要注意的是，这仅仅在反引号内有效，其他引号不允许这种嵌入。

alert("the result is ${1 + 2}"); // the result is ${1 + 2}（使用双引号则不会计算 ${…} 中的内容）

Boolean类型（逻辑类型）

        boolean 类型仅包含两个值：true 和 false。

null 类型

        特殊的 null 值不属于上述任何一种类型。

undefined值

        特殊值 undefined 和 null 一样自成类型。

        undefined 的含义是 未被赋值。

Object和Symbol类型

        object 类型是一个特殊的类型。

        其他所有的数据类型都被称为“原始类型”，因为它们的值只包含一个单独的内容（字符串、数字或者其他）。相反，object 则用于储存数据集合和更复杂的实体。

        因为它非常重要，所以我们对其进行单独讲解。在充分学习了原始类型后，我们将会在 对象 一章中介绍 object。

  symbol 类型用于创建对象的唯一标识符。我们在这里提到 symbol 类型是为了完整性，但我们要在学完 object 类型后再学习它。

typeof 运算符

  typeof 运算符返回参数的类型。当我们想要分别处理不同类型值的时候，或者想快速进行数据类型检验时，非常有用。

对 typeof x 的调用会以字符串的形式返回数据类型：

typeof undefined     // "undefined"typeof 0             // "number"typeof 10n           // "bigint"typeof true          // "boolean"typeof "foo"         // "string"typeof Symbol("id")  // "symbol"typeof Math          // "object"   (1)
typeof null          // "object"   (2)
typeof alert         // "function" (3)

最后三行可能需要额外的说明：

1. Math 是一个提供数学运算的内建 object。我们会在 数字类型 一节中学习它。此处仅作为一个 object 的示例。
2. typeof null 的结果为 "object"。这是官方承认的 typeof 的错误，这个问题来自于 JavaScript 语言的早期阶段，并为了兼容性而保留了下来。null 绝对不是一个 object。null 有自己的类型，它是一个特殊值。typeof 的行为在这里是错误的。
3. typeof alert 的结果是 "function"，因为 alert 在 JavaScript 语言中是一个函数。我们会在下一章学习函数，那时我们会了解到，在 JavaScript 语言中没有一个特别的 “function” 类型。函数隶属于 object 类型。但是 typeof 会对函数区分对待，并返回 "function"。这也是来自于 JavaScript 语言早期的问题。从技术上讲，这种行为是不正确的，但在实际编程中却非常方便。

总结：

JavaScript 中有八种基本的数据类型（译注：前七种为基本数据类型，也称为原始数据类型，而 object 为复杂数据类型）。

• 七种原始数据类型：
  • number 用于任何类型的数字：整数或浮点数，在 ±(253-1) 范围内的整数。
  • bigint 用于任意长度的整数。
  • string 用于字符串：一个字符串可以包含 0 个或多个字符，所以没有单独的单字符类型。
  • boolean 用于 true 和 false。
  • null 用于未知的值 —— 只有一个 null 值的独立类型。
  • undefined 用于未定义的值 —— 只有一个 undefined 值的独立类型。
  • symbol 用于唯一的标识符。
• 以及一种非原始数据类型：
  • object 用于更复杂的数据结构。

我们可以通过 typeof 运算符查看存储在变量中的数据类型。

• 通常用作 typeof x，但 typeof(x) 也可行。
• 以字符串的形式返回类型名称，例如 "string"。
• typeof null 会返回 "object" —— 这是 JavaScript 编程语言的一个错误，实际上它并不是一个 object。

TypeScript基础语法

        TypeScript在JavaScript的基础上加入了静态类型检查功能，因此每一个变量都有固定的数据类型。

// string: 字符串，可以使用单引号或双引号
let msg: string = 'hello world'

// number: 数值，整数、浮点数都可以
let age: number = 21

// boolean: 布尔
let a:any = 'jack'
a = 21

// union: 联合类型，可以使多个指定类型中的一种
let u : string|number|boolean = 'rose'
u = 18

// Object: 对象
let p = {name: 'Jack', age: 21}
console.log(p.name)
console.log(p['name'])

// Array: 数组，元素可以使任意其他类型
let names: Array<string> = ['Jack','Rose']
let ages: number[] = [21, 18]
console.log(names[0])

判断

let num: number = 21

//判断是否为偶数
if(num === 0){
    console.log(num + '是偶数')
}else{
    console.log(num + '是奇数')
}

循环 

let names: string[] = ['jach','tony']

for(let i in names){
    console.log(names[i])
}

for(let name of names) {
    console.log(name)
}

函数 

        TypeScript通常利用function关键字声明函数，并且支持可选参数、默认参数、箭头函数等特殊语法。

//无返回值函数，返回值void可以省略
function sayHello(name: string):void{
    console.log('你好，' + name +'!')
}
sayHello('jack')

//有返回值函数
function sum(x:number,y:number):number{
    return x + y
}
let result = sum(10,2)
console.log('10 + 2 = ' + result)

//可选参数，在参数名后加？表示该参数是可选的
function sayHello1(name?: string){
    name = name?name : '陌生人'
    console.log('你好，' + name +'!')
}
sayHello1('jack')
sayHello1()

//参数默认值，在参数后面赋值，表示参数默认值
//如果调用者没有传参，则使用默认值
function sayHello2(name: string = '陌生人'){
    console.log('你好，' + name +'!')
}
sayHello2('jack')
sayHello2()

TypeScript具备面向对象编程的基本语法，例如interface、class、enum等。也具备封装
继承、多态等面向对象基本特征。

//定义枚举
enum Msg{
    HI = 'Hi',
    HELLO = 'hello'
}

//定义接口，抽象方法接受枚举参数
interface A{
    say(msg: Msg):void
}

//实现接口
class B implements A{
    say(msg: Msg): void{
        console.log(msg + ', I am B')
    }
}

//初始化对象
let a:A = new B()

//调用方法，传递枚举参数
a.say(Msg.HI)

//定义矩形类
class Rectangle {
    //成员变量
    private width: number
    private length: number
    //构造函数
    constructor(width: number,length: number){
        this.width = width
        this.length = length
    }
    //成员方法
    public area(): number{
        return this.width * this.length
    }
}

//定义正方形
class Square extends Rectangle{
    constructor(side: number){
        //调用父类构造
        super(side,side)
    }
}

let s = new Square(10)
console.log('正方形面积为：' + s.area())