1.1 字符串
// 变量的存储和修改（string number boolean）
// 1. 变量存储
// 1.1 字符串 string 类型
// 注意点1：字符串需要用引号引起来（单引双引号）'字符串' "字符串"
// 注意点2：存储的时候，后面的存的内容，需要和前面的类型对应
let title: string = '巨无霸汉堡'
console.log('字符串title', title)
// 1.2 数字 number 类型
let age: number = 18
console.log('年纪age', age)
// 1.3 布尔 boolean 类型(true真，false假)
let isLogin: boolean = false
console.log('是否登录成功', isLogin)
// 2. 变量的修改
age = 40
console.log('年纪age', age)
// 常量
const PI: number = 3.14
const companyName: string = '华为'
console.log('公司名：', companyName)
console.log('PI:', PI)
// 字符串拼接 + 拼串
let name: string = '吕布'
let age: number = 18
console.log('简介信息:', '姓名' + name)
console.log('简介信息:', '年纪' + age)
// 注意点: + 两边只要有字符串, 就是拼串的作用 (如果两边都是数字, 就是计算求和的作用)
let num1: number = 100
let num2: number = 200
console.log('总数', num1 + num2)
---------------------------------------------
// 模板字符串 `` (支持变量, 更利于字符串拼接) 普通字符串 '' ""
// let str: string = `hello world`
//
let name: string = '成小龙'
let age: number = 18
let hobby: string = '打拳'
console.log('简介信息', `姓名: ${name}, 年纪: ${age}岁, 爱好: ${hobby}`)
1.2 数组
// 学生数组
// 语法：
// let 数组名: 类型[] = [数据1, 数据2, 数据3, ... ]
// 1.数组中存储的每个数据，都有自己的编号，编号从0开始（索引）
let names: string[] = ['刘亦菲', '杨颖', '杨幂', '刘诗诗', '伍佰']
console.log('数组names', names)
// 2.利用有序的编号(索引) 取数组的数据
// 取数据：数组名[索引]
console.log('取到了', names[3])
// 3. 数组修改(通过下标)
names[2] = '赵云'
console.log('修改数组', names)
// 4.添加
// 1. 往开头新增 unshift(新增的值) 返回操作后的数组的长度
songs.unshift('彩虹')
console.log('返回数组长度', songs.unshift('七里香'))
console.log('数组songs', songs)
// 5. 往结尾新增 push(新增的值) 返回操作后的数组的长度
songs.push('光辉岁月', '海阔天空')
console.log('数组', songs)
// 6.删除
// 1. 从开头删 shift
console.log('返回删除的项', songs.shift())
console.log('返回删除的项', songs.shift())
console.log('数组', songs)
// 7. 从结尾删 pop
songs.pop()
songs.pop()
songs.pop()
console.log('数组', songs)
// 开头(S): unshift(开头增) shift(开头删)
// 结尾(P): push(结尾增) pop(结尾删)
// 8.定义一个数组
let songs: string[] = ['告白气球', '洋葱', '吻别', '双节棍', '曹操']
// splice 在任意位置进行删除或新增内容
// 数组名.splice(操作的起始位置, 删除几个, 新增的项1, 新增的项2, ...)
// 8.1. 删除(任意位置)
// songs.splice(2, 2)
// console.log('数组songs', songs)
// 8.2. 新增(任意位置)
// songs.splice(1, 0, '彩虹') // 新增
// 8.3. 替换(删了一项, 又加了一项)
// songs.splice(1, 1, '彩虹')
// console.log('数组songs', songs)
-----------------------------剩余参数和展开运算符---------------------------
// ...数组名 => 可以收集剩余的参数
function sum (n1: number, n2: number, ...argsArr: number[]) {
let total: number = n1 + n2
// 遍历剩余参数, 如果有剩余的参数, 就继续累加
for (let temp of argsArr) {
total += temp
}
console.log('结果', total)
return total
}
sum(1, 2)
sum(1, 2, 3, 4)
sum(1, 2, 3, 4, 5, 6)
// ... 展开运算符, 用于数组的平铺合并
let arr1: number[] = [1,2,3]
let arr2: number[] = [4,5,6]
let newArr: number[] = [...arr1, ...arr2]
console.log('最终的数组', newArr)
1.3 函数
// 1. 定义函数 (只是定义了函数，但是没有使用，不会执行内部的代码段)
function star() {
console.log('五角星', '☆')
console.log('五角星', '☆☆')
console.log('五角星', '☆☆☆')
console.log('五角星', '☆☆☆☆')
console.log('五角星', '☆☆☆☆☆')
}
// 2. 调用函数（使用函数）
// 函数名()
star()
//3.带返回值对函数
function buy(price: number, num: number) {
console.log('传入的数据', price, num)
// 1. 处理数据
let result: number = price * num
// 2. 返回结果
return result
}
//4.函数调用
let apple: number = buy(2, 3)
console.log('苹果', apple)
let banana: number = buy(4, 4)
console.log('香蕉', banana)
// 注意点：形参和实参的数量要统一，一一对应
1.4 箭头函数
//1.构建函数
let buy = (price: number, weight: number) => {
// 1. 计算数据
let result: number = price * weight
// 2. 返回计算的结果
return result
}
//2.调用函数
let apple: number = buy(2, 3)
console.log('苹果', apple)
1.5 定义接口-对象
// 1. 定义接口
interface Person {
name: string
age: number
weight: number
}
// 2. 基于接口，定义对象
let ym: Person = {
name: '大幂幂',
age: 18,
weight: 90
}
// 3. 获取对象属性值 对象名.属性名
console.log('体重:', ym.weight)
1.6 对象-方法的使用
// 1. 定义接口
interface Person {
name: string
age: number
weight: number
// ① 定义方法的类型
sing: (song: string) => void
dance: () => void
}
// 2. 基于接口，定义对象
let ym: Person = {
name: '大幂幂',
age: 18,
weight: 90,
// ② 定义方法
sing: (song: string) => {
console.log('杨幂说', '我来唱首歌', song)
},
dance: () => {
console.log('杨幂说', '我来跳个舞')
}
}
// ③ 调用对象里面的方法 （重要！！）
ym.sing('爱的供养')
ym.dance()
1.7 联合类型
// 联合类型还可以将变量值，约定在一组数据范围内进行选择
// 性别：男 女 保密
let gender: 'man' | 'woman' | 'secret' = 'secret'
1.8 枚举
// 1. 定义枚举 （定义常量列表）
enum ThemeColor {
Red = '#ff0f29',
Orange = '#ff7100',
Green = '#30b30e'
}
// 2. 给变量设定枚举类型
let color: ThemeColor = ThemeColor.Orange
console.log('color', color)
3.5if-else
// 分支语句 - if 语句
// 1. 单分支 (满足条件, 就会执行一段代码)
// if (逻辑条件) {
// 条件成立时执行的代码
// }
// 2. 双分支 (满足条件, 会执行A代码, 不满足条件, 会执行B代码)
// if (逻辑条件) {
// 条件成立时执行的代码
// }
// else {
// 条件不成立时执行的代码
// }
if (score >= 90) {
console.log('奖励', '一台游戏机')
}
else {
console.log('惩罚', '写个检讨, 分析出错原因')
}
3.6 switch
switch (fruit) {
case '苹果':
console.log('苹果价格:', '2.8元一斤')
break
case '香蕉':
console.log('香蕉价格:', '5.5元一斤')
break
case '西瓜':
console.log('西瓜价格:', '1.5元一斤')
break
default:
console.log('提示:', '尊敬的用户, 该水果不存在')
}
3.7 三元表达式
// 三元条件表达式
// 语法: 条件 ? 条件成立执行的表达式 : 条件不成立执行的表达式
let num1: number = 40
let num2: number = 30
// let max: number = num1 > num2 ? num1 : num2
// console.log('三元条件表达式', max)
let res: number = num1 > num2 ? 3 * 5 : 2 + 6
console.log('三元条件表达式', res)
3.8 条件渲染
// 条件渲染: 不同的条件, 控制不同的UI界面展示
Column() {
if (this.age < 18) {
Text('未成年, 18岁以下')
}
else if (this.age < 60) {
Text('成年人, 18~60岁')
}
else {
Text('老年人, 60+')
}
Button('长大').onClick(() => {
this.age += 5
})
Text(`当前年纪: ${this.age}`)
}
3.9 while循环
let i: number = 1
let sum: number = 0 // 存储累加的结果
while (i <= 10) {
console.log('需要累加的数字:', i)
// 每次执行下面这行代码, 就会进行一次累加, 并且更新累加的结果
sum = sum + i
i++
}
3.10 for循环
// 1-10的和, 从1开始,循环到10
let sum = 0
for (let i: number = 1; i <= 10; i++) {
console.log('for', i)
sum = sum + i // sum += i
}
console.log('求和', sum)
--------------------------------------------
// 退出循环:
// 1. break: 终止整个循环 (后面的循环不执行了)
// 2. continue: 退出当前这一次循环, 继续执行下一次循环 (包子当前这个不吃了, 吃下一个)
for (let i: number = 1; i <= 8; i++) {
if (i == 5) {
console.log('拿起了第5个包子, 发现坏了')
// 当前这次循环不继续执行了, 继续执行下一次循环
continue
}
console.log('吃包子:', `第${i}个`)
-------------------------写法2---------------------------
for (let item of names) {
console.log('数组中的每一项', item)
}
-------------------------写法3---------------------------
ForEach(this.historyArr, (item: Resp, index: number) => {
})
9.1 类
// 类
// class 类名 {
// 字段名:类型 = 初始值
// 字段名?:类型
// }
class Cat {
name: string = 'Tom'
foods?: string
}
// 基于类, 创建对象
let p: Cat = new Cat()
console.log('姓名:', p.name.length)
p.foods = '小黄鱼'
console.log('食物:', p.foods?.length)
@Entry
@Component
struct Index {
build() {
}
}
-----------------构造函数语法--------------------
// 构造函数语法
// class Food {
// name: string
// price: number
// // 希望不同实例, 有不同的字段初始值 → 构造函数
// constructor(name: string, price: number) {
// this.name = name
// this.price = price
// }
// }
// let f1: Food = new Food('西兰花', 20)
// console.log('名称:', f1.name, '价格:', f1.price)
//
// let f2: Food = new Food('土豆炖鸡块', 28)
// console.log('名称:', f2.name, '价格:', f2.price)
interface IFood {
name: string
price: number
desc: string
}
class Food {
name: string
price: number
desc: string
// 希望不同实例, 有不同的字段初始值 → 构造函数
constructor(paramsObj: IFood) {
this.name = paramsObj.name
this.price = paramsObj.price
this.desc = paramsObj.desc
}
}
let p1: Food = new Food({
name: '西兰花',
desc: '好吃',
price: 20
})
let p2: Food = new Food({
name: '黄瓜炒鸡蛋',
desc: '清爽',
price: 12
})
console.log('名称', p1.name)
console.log('名称', p2.name)
@Entry
@Component
struct Index {
build() {
}
}
------------------------定义方法------------------------
// 类 → 定方法
class Person {
name: string
age: number
constructor(name: string, age: number) {
this.name = name
this.age = age
}
// 跟xxx打招呼, 还要自我介绍
sayHi(yourName: string) {
// 通过this可以访问到创建出来的实例对象
console.log(`hello, ${yourName}, 我是${this.name}`)
}
sing(): string {
return '稻香'
}
}
let p1:Person = new Person('凹凸曼', 18)
p1.sayHi('小怪兽')
let p2:Person = new Person('大灰狼', 5)
p2.sayHi('小绵羊')
@Entry
@Component
struct Index {
build() {
}
}
----------------------------静态属性和静态方法------------------------
// 静态属性 和 静态方法
class Robot {
static version: string = 'v2.0'
static getRandom(): number {
return Math.random()
}
}
console.log('Robot类的版本', Robot.version)
console.log('工具方法:', Robot.getRandom())
------------------------------类的继承-----------------------------------
// 父类 子类
// 人类 学生, 老师, 工人
class Person {
name: string
age: number
constructor(name: string, age: number) {
this.name = name
this.age = age
}
sayHi() {
console.log('大家好~', this.name, this.age)
}
}
class Student extends Person {
grade: string
constructor(name: string, age: number, grade: string) {
// 父类中的构造函数, 此时需要我们手动调用 super() 构造函数, super.方法名(), super.属性名
super(name, age)
// 完成自己属性的初始化
this.grade = grade
}
study () {
console.log('我是学生, 我爱学习~')
}
// 子类中想要重写父类中的方法, 只需提供同名的方法即可
sayHi(): void {
super.name // 获取父类的属性
super.age // 获取父类的属性
super.sayHi() // 调用了父类的方法
console.log('hello, nice to meet you'); // 扩展了自己的特性
}
}
let s1: Student = new Student('小明', 18, '五年级')
s1.sayHi() // 调用重写的sayHi方法
// s1.study() // 调用自己的study方法
// console.log(s1.grade) // 访问自己的grade属性
let s2: Student = new Student('小蓝', 18, '三年级')
// console.log(s2.grade)
// class Teacher extends Person {
// }
// let t1: Teacher = new Teacher('李老师', 35)
// t1.sayHi() // 调用父类的sayHi方法
//
//
// class Worker extends Person {
// }
-----------------判断是否是这个类-------------------------
class Person {}
class Student extends Person {}
class Worker extends Person {}
let s: Student = new Student()
console.log('判断结果:', s instanceof Student)
console.log('判断结果:', s instanceof Person)
console.log('判断结果:', s instanceof Worker)
interface IObj {}
// 判断一个变量是否存的是数组
let temp: IObj = {}
console.log('是否是数组', temp instanceof Array)
---------------------修饰符 readonly --------------------------------
// 修饰符 readonly
class Cat {
name: string
age: number
readonly legs: number = 4
constructor(name: string, age: number) {
this.name = name
this.age = age
}
}
let c1 = new Cat('小花', 2)
c1.name = '小美'
// c1.legs = 6 // 不能修改
console.log('姓名:', c1.name)
------------------修饰符 private----------------
// class Person {
// private name: string = ''
// private age: number = 0
// desc: string = '描述'
// }
// let p = new Person()
// console.log('实例访问:', p.name) // 无法再外部访问私有数据
// class Student extends Person {
// sayHi () {
// console.log('访问私有的数据:', super.name) // 私有数据无法再(子类)访问
// }
// }
---------------------修饰符 protected和public--------------------------------
class Person {
protected name: string
protected age: number
desc: string = '描述'
// 类的内容, 无论是私有还是保护, 都是可以访问的
constructor(name: string, age: number) {
this.name = name
this.age = age
}
}
let p = new Person('小王', 18)
// console.log('实例访问:', p.name) // 无法在外部, 访问受保护的数据
class Student extends Person {
sayHi () {
console.log('访问私有的数据:', super.name) // 保护的数据可以在子类访问
}
}
10.1 接口
------------------------------接口的继承---------------
interface IAnimal {
name: string
age: number
}
interface ICat extends IAnimal {
hair: string
}
interface IDog extends IAnimal {
color: string
}
let dog1: IDog = {
name: '小泰迪',
age: 2,
color: '棕色'
}
---------------------------接口的实现-----------------------
// 接口实现: 定义一个接口, 约束类 => 类需要按照接口的要求, 实现类的主体
interface IDog {
name: string
age: number
jump: () => void
}
// 基于接口, 实现类
class Dog implements IDog {
name: string
age: number
desc: string
constructor(name: string, age: number, desc: string) {
this.name = name
this.age = age
this.desc = desc
}
jump() {
}
}
let dog: Dog = new Dog('小飞', 2, '是一只非常帅气的二哈')
dog.jump()
function 函数名<Type>(temp:Type):Type{
return temp
}
11.1泛型
// 泛型: 广泛的类型 => 类型可以作为参数传递过来, 类型是[可变]的
// function 函数名<Type> (形参: Type): Type {
// return 形参
// }
// 封装了一个函数: 传入什么样的参数, 就立刻返回什么样的参数
function fn<T> (param: T) : T {
return param
}
fn<string>('abc')
fn<number>(123)
fn<boolean>(true)
fn<number[]>([1, 2, 3, 4, 5])
// 会默认根据传参, 进行类型推断, 动态的配置 T 类型参数 的值
fn(true)
fn([1, 2, 3, 4, 5])
// 练习1: 定义函数, 参数是数组(存的类型不定), 返回数组的长度
function getLength<T> (arr: T[]) : number {
return arr.length
}
console.log('', getLength<number>([1, 2, 3]))
console.log('', getLength<string>(['1', 'aa', 'bb', 'cc']))
// 练习2: 定义函数, 参数是数组(存的类型不定), 返回数组的最后一项
function getLast<T> (arr: T[]) : T {
return arr[arr.length - 1]
}
console.log('', getLast<number>([1, 2, 3, 4, 99]))
console.log('', getLast<string>(['a', 'b', 'c']))
------------------------------------------泛型的约束----------------
// 泛型约束: 给传递的类型参数, 添加限制
interface ILength {
length: number
}
function fn<T extends ILength>(param: T) {
console.log('', param.length)
}
fn<string>('abc')
fn<number[]>([1, 2, 3])
class Desk {
length = 2
}
let d = new Desk()
----------------------------多个泛型变量------------------------------
// 多个泛型变量 => 传递多个类型参数
function fn<T1, T2> (param1: T1, param2: T2) {
console.log('参数1', param1)
console.log('参数2', param2)
}
fn<string, boolean>('abc', true)
fn<number, string>(123, 'abc')
fn<string[], number[]>(['a', 'b'], [1, 2])
fn<Desk>(d)
--------------------------泛型接口------------------------------------
// 泛型接口
interface IdFunc<T> {
// 约定有两个方法 (id类型不定, string number)
// 1. 传入 id 值, 就返回 id 值
// 2. 返回一个 ids 数组
id: (value: T) => T
ids: () => T[]
}
let obj: IdFunc<number> = {
id(value: number) {
return value
},
ids() {
return [1, 2, 3]
}
}
let obj2: IdFunc<string> = {
id(value: string) {
return value
},
ids() {
return ['001', '002', '003']
}
}
---------------------------泛型类--------------------------------------
// 泛型类: 定义类的时候, 配合泛型一起定义
class Person <T>{
id: T
constructor(id: T) {
this.id = id
}
getId (): T {
return this.id
}
}
let p: Person<number> = new Person<number>(10)
let p2: Person<string> = new Person<string>('abc')
3.1字符串转数字
let str1: string = '1.1'
let str2: string = '1.9'
let str3: string = '1.99a'
let str4: string = 'a'
// 转数字类型
// 1. Number(变量) 原样转数字
console.log('Number', Number(str1)) // 1.1
console.log('Number', Number(str2)) // 1.9
console.log('Number', Number(str3)) // NaN
console.log('Number', Number(str4)) // NaN
// 2. parseInt(变量) 去掉小数部分(取整)
console.log('parseInt', parseInt(str1)) // 1
console.log('parseInt', parseInt(str2)) // 1
console.log('parseInt', parseInt(str3)) // 1
console.log('parseInt', parseInt(str4)) // NaN
// 3. parseFloat(变量) 保留小数部分
console.log('parseFloat', parseFloat(str1)) // 1.1
console.log('parseFloat', parseFloat(str2)) // 1.9
console.log('parseFloat', parseFloat(str3)) // 1.99
console.log('parseFloat', parseFloat(str4)) // NaN
3.2数字转字符串
// 数字通常用于计算, 字符串通常用于展示
let money: number = 10000
// 将数字转字符串, toString() toFixed()
// 1. 数据.toString() 原样转字符串
console.log('toString:', money.toString())
// 2. 数据.toFixed(保留几位小数) 四舍五入
console.log('toFixed:', money.toFixed())
console.log('toFixed:', money.toFixed(2))
5.2 对象转字符串
JSON.stringify(err)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
