0
点赞
收藏
分享

微信扫一扫

【OpenAI】第六节（语音生成与语音识别技术）从 ChatGPT 到 Whisper 的全方位指南

颜路在路上 2024-11-05 阅读 11
harmonyos华为

文章目录

  • 华为官方教程
  • B站视频教程

快速入门

根据官方教程新建一个项目：构建第一个ArkTS应用（Stage模型）

ArkTS基本语法

数据类型

  1. 按以下方式，在项目src/main/ets/pages目录下，新建一个dataType.ets文件，内容如下：
    在这里插入图片描述
@Entry
@Component
struct DataType {
  @State message: string = 'hello world';

  build() {
    Column() {
      Button('数字类型').onClick(()=>{
        let n1: number = 10
        let n2: number = 43.5
        let n3 = n1 + n2
        console.log('ken', n3)
          // 进制表示
        // 二进制，八进制，十六进制
        let b1: number = 0o12  // 八进制 15
        let b2: number = 0x17  // 十六进制 23
        let b3: number = 0b1111 // 二进制 15
        console.log('ken', b1, b2, b3)

        let bFlag: boolean = true
        let bFlag2: boolean = false
        let bFlag3: boolean = false
        console.log('ken', bFlag, bFlag2, bFlag3)
      })

      Button('字符串类型').onClick(()=>{
        // 字符串类型，字符的数组
        let s1: string = 'hello, this is demo'
        let s2: string = 'hello, this is demo'
        let n: number = 100
        let s3: string = 'hello, this price is ${n} \t s1'
        console.log('ken', s3)
      })

      Button('枚举类型').onClick(()=>{
        // 枚举类型及其取值
        let you: Man = Man.GoodMan
        console.log('ken', you==0)
        console.log('ken', you===0)
      })

      Button('联合类型').onClick(()=>{
        // 一个变量可以定义为多种类型的组合
        let score: string | number | null = 'A'
      })
      Button('数组类型').onClick(()=>{
        // 静态初始化
        let arr: string [] = ['1', '2', '12', '22']
        // new初始化
        let arr2: number [] = new Array(10)
        // 下标
        console.log('ken', arr[3])
        // 支持动态扩容
        arr2[100] = 100
        console.log('ken', arr2.length)
      })
    }
    .height('100%')
    .width('100%')
  }
}

enum Man {
  GoodMan,
  BadMan,
  SexMan
}

运算符\分支&循环

import { beforeItSpecified } from '@ohos/hypium';

@Entry
@Component
struct SignPage {
  @State message: string = 'Hello World';

  build() {
    Column() {
      Button('运算符').onClick(()=>{
        // 赋值运算符 =, +=, -=, *=, /=, %=
        let a = 10
        let b = 20
        a += b
        console.log('ken', a, b)

        // 算术运算符 +, -, *, /, %, ++, --

        // 关系运算符 >, <, ==, >=, <=, !=

        // 逻辑运算符 &&, ||, !
        // 给定年份，判断是否是闰年，能被4但是不能被100或能被400整除的
        let year = 2000
        if ((year %4 == 0 && year % 100 != 0) || year % 400 == 0) {
          console.log('ken', year + '是闰年')
        } else {
          console.log('ken', year + '是平年')
        }

        // 位运算符


        // 三元运算符
      })
      Button('成绩等级').onClick(()=>{
        let score = 90
        if (score >= 90) {
          console.log('ken', '优秀');
        } else if (score >=80) {
          console.log('ken', '良好');
        } else {
          console.log('ken', '还需加油');
        }
      })
      // 分支和循环
      Button('菜单').onClick(()=>{
        let arr: string[] = [
          "1:红烧肉",
          "2:红烧鸡",
          "3:红烧排骨",
          "4:小草白菜"
        ]
        let foodStr: string
        let food = 1
        switch (food) {
          case 1:
            foodStr = arr[0]
          case 2:
            foodStr = arr[1]
          case 3:
            foodStr = arr[2]
          case 4:
            foodStr = arr[3]
          default:
            foodStr = "没有这道菜"
        }
        AlertDialog.show({message:"您选择的食物是" + foodStr})
      })
      Button('循环结构1').onClick(()=>{
        let arr: string[] = [
          "1:红烧肉",
          "2:红烧鸡",
          "3:红烧排骨",
          "4:小草白菜"
        ]

        for (let i = 0; i < arr.length; i++) {
          console.log('ken for', arr[i])
        }
        for (let a of arr) {
          console.log('ken for of', a)
        }
        let index = 0
        while (true) {
          if (index >= arr.length) {
            break
          }
          console.log('ken while', arr[index])
          index++
        }
        do {
          console.log('ken do while', arr[index])
          index++
        }while (index < arr.length)
      })
    }
    .height('100%')
    .width('100%')
  }
}

ArkTS函数

@Entry
@Component
struct CustomFunction {
  @State message: string = 'Hello World';

  build() {
    Column() {
      Button('函数测试').onClick(()=>{
        printMyName()
        let ret = getArea(10, 20)
        console.log('ken ret', ret)
        let ret2 = printNum(10, 20)
        console.log('ken ret2', ret2)
        fn1()
        let ret3 = fn2(10)
        console.log('len fn2', ret3)
      })
      Button('函数类型').onClick(()=>{
        //函数引用，创建一个指向某个函数的指针
        let fn: myFuncType = printCfg
        fn()
        let fn2: myFuncType2 = calcSum
        let ret = fn2(100)
        console.log('ken ret2', ret)
      })
      Button('回调函数').onClick(myBtnClickFun)
    }
    .height('100%')
    .width('100%')
  }
}

// 函数使用什么变量可以指向它？
/*
type myFuncTyoe = ()=>void
 */
// 定义函数类型，可用于指向某个函数
type myFuncType = ()=>void
type myFuncType2 = (n?: number)=>number

// 用一个类型的变量指向这个函数
function  printCfg() {
  for (let i = 1; i < 10; i++) {
    for (let j = 1; j <= i; j++) {
      console.log('ken ' + j+'*'+i+'='+(i*j))
    }
  }
}

//箭头函数，也是匿名函数
// 无参数也无返回值的
let fn1 = ()=>{
  console.log('ken fn1', '箭头函数>...')
}
// 定义回调函数，指向fn1
let myBtnClickFun: myFuncType = fn1

//带参数和返回值的
let fn2 = (a: number): number=>{
  return 0
}

// 函数的调用

// 函数的定义
function printMyName() {
  console.log('ken', 'my name is ken')
  printYourName()
}

function printYourName() {
  console.log('ken', 'your name is aniu')
}

/*
长方形的面积
* 可选参数：?
 */

function getArea(a: number, b?: number): number {
  if (b == undefined) {
    return -1
  }
  let area = a * b
  return area
}
/*
可变参数
* Rest参数：可以传递多个离散的某个类型的参数
* 必须放在参数列表的最后一个位置，不能是中间，也不能是开头
 */

function printNum(...nums: number[]) {
  let res = 0
  for (let n of nums) {
    res += n
  }
  return res
}


function calcSum(n?: number):number {
  if (n == undefined) {
    return -1
  }
  return 1
}

ArkTS类

类的定义

在独立文件中写好类，如src/main/ets/common/Employee.ets

/*
定义员工类
* 类的属性必须初始化（静态初始化） 或 采用构造方法constructor的方式
 */
 // export的类在其他位置可以使用
export class Employee {
  /*
  属性用字段来表示
   */
  // 有三个访问修饰符：private, protected, public
  // 默认是public
  name: string
  sex: string
  private _sal: number
  comm: number
  // 构造方法，只能写一个，不能写多个
  constructor(name: string, sex: string, sal: number, comm: number) {
    this.name = name
    this.sex = sex
    this._sal = sal
    this.comm = comm
  }

  public set sal(value: number) {
    this._sal = value
  }

  public get sal(): number {
    return this._sal
  }

  /*
  行为用函数来定义
   */
  show() {
    console.log('ken', this.name, this.sex, this.sal, this.comm)
  }
  /*
  计算收入
   */
  getIncome() {
    return this._sal + this.comm
  }
}

在主页面文件中使用类

import { Employee} from '../common/Employee';


@Entry
@Component
struct ClassPage {
  @State message: string = 'Hello World';

  build() {
    Column() {
      Button('对象测试1').onClick(()=>{
        let emp = new Employee("阿牛", "男", 8000, 0)
        emp.show()
        console.log('ken', '收入', emp.getIncome())
      })
    }
    .height('100%')
    .width('100%')
  }
}

类的继承

src/main/ets/common/Employee.ets

/*
定义员工类
* 类的属性必须初始化（静态初始化） 或 采用构造方法constructor的方式
 */
export class Employee {
  /*
  属性用字段来表示
   */
  // 有三个访问修饰符：private, protected, public
  // 默认是public
  name: string
  sex: string
  sal: number
  comm: number
  // 构造方法，只能写一个，不能写多个
  constructor(name: string, sex: string, sal: number, comm: number) {
    this.name = name
    this.sex = sex
    this.sal = sal
    this.comm = comm
  }

  /*
  行为用函数来定义
   */
  show() {
    console.log('ken', this.name, this.sex, this.sal, this.comm)
  }
  /*
  计算收入
   */
  getIncome() {
    return this.sal + this.comm
  }
}


/*
继承：子类可以继承父类的非私有属性和方法
 */

export class Programmer extends Employee {
  getIncome(): number {
    return this.sal + this.comm + 500
  }

  // 子类对象的产生晚于父类，因此需要加入super关键词
  constructor(name: string, sex: string) {
    super(name, sex, 0, 0)
    this.name = name
    this.sex = sex
  }
}


export class Manager extends Employee {
  getIncome(): number {
    return this.sal + this.comm + 1500
  }
}


export class Tester extends Employee {
  getIncome(): number {
    return this.sal + this.comm + 800
  }
}


export class Fronter extends Employee {

}

src/main/ets/pages/ClassPage.ets

import { Employee, Programmer, Manager, Tester, Fronter} from '../common/Employee';


@Entry
@Component
struct ClassPage {
  @State message: string = 'Hello World';

  build() {
    Column() {
      Button('继承案例').onClick(()=>{
        let emp1 = new Programmer("阿朱", "女")
        let emp2 = new Manager("ken", "男", 40000, 1000)
        let emp3 = new Tester("阿紫", "女", 11000, 200)
        let emp4 = new Fronter("小四", "男", 6000, 1000)
        AlertDialog.show(
          {message: emp1.getIncome() + " " + emp2.getIncome() + " " + emp3.getIncome() + " " + emp4.getIncome()})
      })
    }
    .height('100%')
    .width('100%')
  }
}

多态

src/main/ets/common/Food.ets

/*
食物类
 */
class Food {
  beCook() {

  }
}


export class Vegetable extends Food {
  beCook(){
    console.log("素菜")
  }
}


export class Fish extends Food {
  beCook(){
    console.log("Fish")
  }
}


export class Pig extends Food {
  beCook(){
    console.log("Pig")
  }
}


/*
厨师类
 */

export class Cooker {
  // // 理论上的静态多态，不建议写这种写法
  // cook(food: Fish)
  // cook(food: Vegetable)
  // cook(food: Pig)
  // cook(food: Pig | Fish | Vegetable) {
  //
  // }
  /*
  动态的多态
   */
  cook(food: Food) {
    food.beCook()
  }
}

src/main/ets/pages/ClassPage.ets

import { Cooker, Fish, Vegetable, Pig } from '../common/Food'


@Entry
@Component
struct ClassPage {
  @State message: string = 'Hello World';

  build() {
    Column() {
      Button('重载').onClick(()=>{
        let cooker = new Cooker()
        cooker.cook(new Fish())
        cooker.cook(new Vegetable())
        cooker.cook(new Pig())
      })
    }
    .height('100%')
    .width('100%')
  }
}

静态成员

静态成员是属于类的，不属于对象，是一种公共字段，为static关键词开头的成员，包括：

  1. 静态字段
  2. 静态方法
  3. 静态代码块

class MyMath {
  // 静态字段
  static pi = 3.1415926
  //静态方法
  static show() {

  }
  //静态代码块：程序被加载就会运行，一个类只能有一个静态代码块
  static {
    console.log('ken', '静态代码块')
  }
}

/*
利用静态，实现单例模式：一个类只有一个对象，这个是类的设计者的责任，而不是使用者的责任
 */

export class DbHelper {
  private static instance: DbHelper | null = null
  // 构造方法私有化
  private constructor() {
  }
  static getInstance(): DbHelper {
    if (DbHelper.instance == null) {
      DbHelper.instance = new DbHelper()
    }
    return DbHelper.instance
  }
}

泛型

src/main/ets/common/Stack.ets

/*
模拟栈
* <T>：类型参数化
 */
/*
通过extends对类型进行约束，export class MinStackExtend<T extends Food> {，就可以约束必须是Food及其子类类型的变量
 */
export class MinStack<T> {
  index: number = -1
  data: T[] = []

  push(o: T) {
    this.index++
    this.data[this.index] = o
  }

  pop(): T {
    let o = this.data[this.index]
    this.index--
    return o
  }

  peek() {
    let o = this.data[this.index]
    return o
  }

  size() {}
}

src/main/ets/pages/ClassPage.ets

import { Employee, Programmer, Manager, Tester, Fronter} from '../common/Employee';
import { Cooker, Fish, Vegetable, Pig } from '../common/Food'
import { MinStack } from '../common/Stack';


@Entry
@Component
struct ClassPage {
  @State message: string = 'Hello World';

  build() {
    Column() {
      Button('泛型测试').onClick(()=>{
        let stack = new MinStack<string>()
        stack.push("我")
        stack.push("爱")
        stack.push("你")
        // 先进先出
        let o = stack.pop()
        console.log('ken', o)
        o = stack.pop()
        console.log('ken', o)
        o = stack.pop()
        console.log('ken', o)
        let stack1 = new MinStack<number>()
        stack1.push(1)
        stack1.push(2)
        stack1.push(3)
        // 先进先出
        let o1 = stack1.pop()
        console.log('ken', o1)
        o1 = stack1.pop()
        console.log('ken', o1)
        o1 = stack1.pop()
        console.log('ken', o1)
      })
      Button('泛型约束').onClick(()=>{
        let o1 = getLast([1, 2, 3])
        console.log('ken', o1)
        let o2 = getLast(['1', '2', '3'])
        console.log('ken', o2)
      })
    }
    .height('100%')
    .width('100%')
  }
}



// 泛型方法
function getLast<T>(arr:T[]): T{
  return arr[arr.length - 1]
}

空值问题

src/main/ets/common/Student.ets

class Dog {
  eat() {
    console.log('ken', '狗吃骨头')
  }
}


export class Student {
  dog?: Dog
  name: string | null = null
  getName(): string | null {
    // 空值合并运算符
    return this.name ?? ""
  }
}

src/main/ets/pages/ClassPage.ets

import { Employee, Programmer, Manager, Tester, Fronter} from '../common/Employee';
import { Cooker, Fish, Vegetable, Pig } from '../common/Food'
import { MinStack } from '../common/Stack';
import { Student } from '../common/Student'


@Entry
@Component
struct ClassPage {
  @State message: string = 'Hello World';

  build() {
    Column() {
      Button('空值问题').onClick(()=>{
        // 四种解决方法

        // 联合类型
        let x: string | null = null
        let y: number | null = null
        let z: object | null = null

        // 非空断言运算符!
        let a: number | null = null
        let b: number
        b = a! + 1
        console.log('ken', b)

        //空值合并运算符 ??
        let stu = new Student()
        console.log('ken', stu.getName())

        // 可选链的问题 stu.dog?.eat()，预防关联代码可能为空指针的问题
      })
    }
    .height('100%')
    .width('100%')
  }
}



// 泛型方法
function getLast<T>(arr:T[]): T{
  return arr[arr.length - 1]
}
举报

相关推荐

chatGPT的耳朵！OpenAI的开源语音识别AI：Whisper ！

人工智能chatgpt语音识别gptwhisper开源

第六节、Docker 方式部署指南 github 上项目 mkdocs-material

github

OpenAI大动作：Whisper large-v3重塑语音识别技术

语音识别开发者语言识别NLP人工智能

OpenAI开源语音识别模型Whisper在Windows系统的安装详细过程

windowswhisperffmpeg语音识别

第六节 使用ISM Web组态软件的自定义数据

前端数据库vue.js数据自定义Linux系统/运维

Spring Security 详解与实操第六节 响应式编程及最后总结

spring security响应式编程java

【魔兽世界插件】魔兽世界插件实战笔记从入门到放弃的心理历程 第六节 窗体对象的锚定

游戏程序lua

渗透测试实战：从入门到精通的全方位指南

网络安全web安全网络安全密码学linuxddos

【PyTorch】第六节：乳腺癌的预测（二分类问题）

springjavamaven

智安网络|语音识别技术：从历史到现状与未来展望

语音识别深度学习声纹识别网络安全
0 条评论