popring's Blog

探索、记录、分享

发表于 分类于

新的一年，应继续保持学习，计划

  • vue 深入学习，之前还是学习的不够深入
  • TypeScript 也应该入手了，都 0202 年了，总不能还不会 ts 吧
  • 走进后端，koa, eggjs 等学一个
  • 不挂科
  • 不挂科
  • 不挂科
阅读全文 »

发表于 分类于

开启管理员模式

1
Start-Process powershell -verb runAs

删除文件夹

1
rm -r -f [文件夹名称]

发表于 分类于

去哪儿网项目链接

Vue-cli 配置

Vue-cli 2.x 和 Vue-cli 3.x 配置webpack别名目录 alias

vue-cli 2.x

1
2
3
4
5
6
7
8
9
10
11
module.exports = {
  resolve: {
    extensions: ['.js', '.vue', '.json'],
    alias: {
      'vue$': 'vue/dist/vue.esm.js',
      '@': resolve('src'),
			// resolve 函数文件已配置好
			'styles': resolve('src/assets/styles')
    }
	}
}

vue-cli 3.x

直接在项目根目录新建 vue.config.js

1
2
3
4
5
6
7
8
9
10
11
12
const path = require('path')

module.exports = {
  configureWebpack: {
    resolve: {
      alias: {
        'styles': path.resolve('src/assets/styles')
      }
    }
  }
}

阅读全文 »

发表于 分类于

Mini Program Notes

尺寸单位 - rpx和px

  • rpx（responsive pixel）: 可以根据屏幕宽度进行自适应。规定屏幕宽为750rpx。如在 iPhone6 上，屏幕宽度为375px，共有750个物理像素，则750rpx = 375px = 750物理像素，1rpx = 0.5px = 1物理像素。
设备rpx换算px (屏幕宽度/750)px换算rpx (750/屏幕宽度)
iPhone51rpx = 0.42px1px = 2.34rpx
iPhone61rpx = 0.5px1px = 2rpx
iPhone6 Plus1rpx = 0.552px1px = 1.81rpx

详情查看官方文档

组件

API

小程序生命周期(Life Cycle)

文档

jpg

事件传参

注意

bindtap或者bindtap(1) 都会会直接当成函数名直接调用包括括号

传参使用自定义属性 data-*

1
2
3
4
5
6
7
<view bindtap="bdtap" data-info="1"></view>

// js代码
bdtap() {
	// e.target.dataset 获取data-*的值
	console.log(e.target.dataset.info)
}

wxs

  • 没有兼容性
  • 与JavaScript不同
  • 隔离性：不能调用js代码，也不能调用小程序提供的API
  • 不能作为事件回调
  • IOS设备比JavaScript运行环境快2~20倍，而在Android和JavaScript环境运行效率无差异

语法

wx:if 控制元素的渲染，为惰性渲染，更高的切换消耗

hidden 始终会渲染，只是简单的控制显示和隐藏，更高的出事渲染消耗

1
2
3
4
5
6
7
8
9
10
11
12
// 相当于 v-if
wx:if=""
wx:elif=""
wx:else

// 控制元素的显示和隐藏
hidden 

// 列表渲染
wx:for=""
wx:for-index=""
wx:for-item=""

block标签

相当于vue中的template，只做包括，当前标签不会渲染出来，内容会渲染

1
<block></block>

自定义组件

数据监听器

类似于Vue中的watch，支持版本2.6.1以上

数据监听器
1
2
3
4
5
6
7
Component({
    observers: {
        '字段1', '字段2': function(字段1的新值，字段2的新值) {
   			// do something         
        }
    }
})
监听子数据字段的变化
1
2
3
4
5
6
7
8
9
10
11
12
Component({
  observers: {
    'some.subfield': function (subfield) {
      // 使用 setData 设置 this.data.some.subfield 时触发
      // （除此以外，使用 setData 设置 this.data.some 也会触发）
    },
    'arr[12]': function (arr12) {
      // 使用 setData 设置 this.data.arr[12] 时触发
      // （除此以外，使用 setData 设置 this.data.arr 也会触发）
    }
  }
})
通配符**监听所有子数据字段的变化
1
2
3
4
5
6
7
8
9
10
Component({
  observers: {
    'some.field.**': function (field) {
      // 使用 setData 设置 this.data.some.field 本身或其下任何子数据字段时触发
      // （除此以外，使用 setData 设置 this.data.some 也会触发）
      field === this.data.some.field
    }
  }
})

组件的生命周期

取消顶部导航栏

1
2
3
4
5
{
    "window": {
        navigationStyle: "custom"
    }
}

将图片转换为base64

1
2
3
const fileManger = wx.getFileSystemManger()
const fileStr = fileManger.readFileSync('dir', 'base64')
// fileStr 即为 图片的base64

hover-class

去除navigator跳转链接的跳转时的默认灰色背景，设置为none

1
2
<navigator hover-class="none">
</navigator>
阅读全文 »

发表于 分类于

第十章 文件操作

文件

文本文件

也称ASCII码文件，每字符占一个字节存储，每字节保存的是字符的ASCII码。可用文本编辑器打开查看，例如.txt、代码源程序.c、等等

二进制文件

以二进制编码的形式保存，例如可执行文件（.exe）、位图文件(.bmp)、word文件(.docx)等都属于二进制文件。这种文件不能用文本编辑器打开查看，强行打开会乱码，无法读懂。

优点：

“全部看作二进制”，输入输出的开始和结束由程序控制而不受换行、空格等字符的限制；比文本文件一般体积小，节省存储空间。

文件的读写

文件操作步骤

1
2
3
4
5
6
7
8
9
10
11
// 定义文件指针
FILE *fp;

// 打开文件（使文件指针关联文件）
fp = fopen(文件名，打开方式);

// 读写文件
// 通过调用系统库函数读写文件，函数中都需要一个文件指针参数fp

// 关闭文件（断开文件指针和文件的关联）
fclose(fp);

向文件写入字符串

如果文件事先已经存在，则会被删除重；如不存在，则直接新建。

fprintf()为写入文件

1
2
3
4
5
6
7
8
9
#include <stdio.h>

int main()
{
    FILE *fp;
    fp = fopen("file.txt","w");
    fprintf(fp, "abc");
    fclose(fp);
}

fopen(char *filename, char *mode)

filename：要打开的文件名称

mode：文件访问模式

modeintroduceremark
r允许读文件（read）文件必须存在，否则出错
w允许覆盖写文件(write)文件必须被新建（如文件已存在会删除源文件，然后新建）
a允许追加写文件（append）文件不存在时才新建，否则只在源文件末尾添加数据
+即允许读也允许写文件
b以二进制格式打开文件（binary）
t以文本格式打开文件（text）

C语言常用文本文件读写函数

函数功能用法
fgetc或getc从当前位置指针处读取文件中的一个字符（1个字符占1个字节），读取后，读写位置指针自动后移1字节字符变量=fgetc(fp);
fputc或putc在当前位置指针处向文件中写入一个字符（1个字符占1个字节），写入后，读写位置指针自动后移1字节fputc(字符, fp);
fgets读取文件中的一个字符串，读写位置指针自动后移fgets(字符数组名, n, fp);
fputs在当前位置指针处向文件中写入一个字符串（不写入’\0’字符，最后也不自动加’\n’）；写入后，位置指针自动后移该字符串长度的字节。fputs(字符串首地址, fp);
fscanf从当前位置指针处按格式读取文件中的多个数据，类似于scanf，只不过不是从键盘输入，而是从文件中读取；读取后，位置指针自动后移fscanf(fp, “格式控制字符串”, 变量1的地址, 变量2的地址, …);
fprintf在当前位置指针处按格式向文件中写入多个数据，类似于printf，只不过不是显示到屏幕上，而是写入到文件中；写入后，位置指针自动后移fprintf(fp, “格式控制字符串”, 数据1, 数据2, …);

C语言常用二进制文件读写函数

函数功能用法
fread从当前位置指针处读取文件中的一批字节，这批字节由count个数据块、每数据块长size个字节组成，共size*count个字节。所读取的字节存入参数buffer地址开始的一段内存空间。读取后，文件位置指针跟随后移实际读取的字节数。函数返回实际读取的数据块数（如读到文件尾或出错，实际读取的数据块数可能小于count）fread(buffer, size, count, fp);
fwrite在当前位置指针处向文件中写入一批字节，这批字节位于内存中参数buffer地址开始的一段内存空间，由count个数据块、每数据块长size个字节组成，共size*count个字节。写入后，文件位置指针跟随后移实际写入的字节数。函数返回实际写入的数据块数（如写入出错，实际写入的数据块数可能小于count）fwrite(buffer, size, count, fp);

C语言常用文件位置指针定位库函数

函数功能用法
rewind把文件位置指针移到文件开头rewind(fp);
fseek把文件位置指针从ori开始的位置，向文件尾部(n>0时)或文件首部(n<0时)移动n个字节。ori可有3种取值： 0、1、2分别表示从文件首、当前位置和文件尾开始移动， 0、1、2也可分别写为符号常量SEEK_SET、SEEK_CUR、SEEK_ENDfseek(fp, n, ori); 一般n为long型，常量加字母后缀L(l)
ftell若执行成功，函数返回当前文件位置指针的位置（文件中第一个字节的位置为0）；若执行失败，函数返回-1n = ftell(fp);
feof判断读文件是否已越过了文件末尾if (feof(fp) ) …

发表于 分类于

第九章 结构体

自定义类型 – 结构体

结构体类型，不占内存，不能保存数据；

内存空间，可以保存数据

1
2
3
4
5
6
7
8
9
struct stu
{
    int num;
    char name[10];
    char sex;
    float score;
};
struct stu boy1;

sizeof对类型和变量均可使用

1
2
sizeof(boy1);
sizeof(struct stu);

结构体类型变量的定义方式

先定义类型，再定义变量

1
2
3
4
5
6
7
8
struct stu
{
    int num;
    char name[10];
    char sex;
    float score;
};
struct stu boy1,boy2;

定义类型的同时，定义变量

1
2
3
4
5
6
7
8
9
struct stu
{
    int num;
    char name[10];
    char sex;
    float score;
}boy1, boy2;

struct stu boy3;

定义类型的同时定义变量，但省略类型名

因无类型名，无法再重新定义其他变量

1
2
3
4
5
6
7
struct
{
    int num;
    char name[10];
    char sex;
    float score;
}boy1, boy2;

结构体类型变量的初始化

1
2
3
4
5
6
7
8
9
10
11
12
struct stu
{
    int num;
    char name[10];
    char sex;
    float score;
};

struct stu boy1,boy2 = {1001, "zhao", 'M', 85.5};

// 可以整体赋值，直接将boy2的值直接赋给boy1
boy1 = boy2;

结构体类型的数组

1
2
3
4
5
struct stu ss[3];

ss[0].num = 1001;
strcpy(ss[1].name, "Qian");
ss[2].score=92.0;

结构指针变量

结构体变量用 .

结构体指针变量用 ->

(*结构体指针变量)用.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct stu boy1;
struct stu *p;
p=&boy1;

p -> num=100;
// 相当于
boy1.num=1001;

strcpy(p->name, "Zhang");
// 相当于
strcpy(boy1.name, "Zhang");

// 此处()不可省略，点和->的优先级都最该(与括号相当)
(*p).score=92.0;
// 相当于
boy1.score=92.0;

结构体类型数据做函数参数

用法与传普通变量类似，

结构体类型变量做函数参数，不会改变原来的实参的值。

结构体指针做函数参数，可以修改原来实参的值。

结构体类型的嵌套

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct date
{
    int year;
    int month;
    int day;
};
struct stu
{
    int num;
    char name[10];
    char sex;
    struct date birthday;
    float score;
};

第二种

1
2
3
4
5
6
7
8
9
10
11
12
13
struct stu
{
    int num;
    char name[10];
    char sex;
    struct
    {
        int year;
        int month;
        int day;
    } birthday;
    float score;
};

类型定义语句typedef

为类型起“绰号”，并不产生新的数据类型，只是给已有的类型增加新名

1
2
3
4
5
typedef double real;

real a,b;
// 相当于
double a,b;

C语言常用内存管理库函数（包含stdlib.h）

函数名介绍备注
malloc分配1块长度为size字节的连续内存空间（不清零），函数返回该空间的首地址；如分配失败函数返回0(类型说明符*)malloc(size)
calloc分配n块、每块长度为size字节的连续内存空间（共size×n字节），并将该空间中的内容全部清零，函数返回该空间的首地址；如分配失败函数返回0(类型说明符*)calloc(n,size)
free释放ptr所指向的一块内存空间，ptr是由malloc或calloc函数所分配空间的地址，即是这两个函数的返回值（或类型转换后的返回值）free(ptr)（ptr为任意基类型的指针）

链表

以链接方式存储的线性表，链表各元素的逻辑结构与存储结构一般不一致。

链表类型：单向链表，双向链表，循环链表。。。

链表介绍

单向链表

一个单向链表的节点分为两个部分，第一部分保存或者显示节点的相关信息，第二部分存储下一个节点的地址。单向链表只向一个方向遍历。

单向链表

链表的一种，特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；列表有节点构成，head指针指向第一个称为表头节点，而终止于最后一个指向NULL的指针。

双向链表

比单向链表多一个的是，双向链表每个节点有两个链接，一个指向前一个节点，而另一个指向下一个节点，当为最后一个节点时，指向空值或空列表。

双向链表

循环链表

在一个循环链表中，首节点和末节点被连接在一起。这种方式，单向和双向都可实现。

循环链表

链表的创建与输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 结构体
struct nodelist
{
    // 数据
	int score;
    // 指向下一个链表的指针
	struct nodelist *next; 
};

// 自定义结构体类型
typedef struct nodelist SNODE;

// 创建链表
SNODE *create_list(int data)
{
	SNODE *head=NULL, *node=NULL, *end=NULL;
	int i;

	head = (SNODE *)malloc(sizeof(SNODE));
	end = head;

	for(i=0; i<data; i++)
	{
		node = (SNODE *)malloc(sizeof(SNODE));
		node->score = i;
		end->next = node;
		end = node;
	}
	end->next = NULL;

	return head;
}

// 输出链表
void out_list(SNODE *h)
{
	SNODE *p;
	p = h->next;
	while(p)
	{
		printf("%d\n", p->score);
		p = p->next;
	}
}




int main()
{
	int data = 3;
	SNODE *head;
	head = create_list(data);
	out_list(head);
    
	system("pause");
}

链表节点的插入和删除

节点的插入
1
2
3
4
p = new struct node;
p->data = 95.5;
p->next = q->next;
q->next = p;
节点的删除
1
2
q->next = p->next;
delete p;

发表于 分类于

第八章 指针（下）

指针变量做函数参数

如果要改变a, b的值，要使用指针指向a,b

输入两个数，如果第一个数大于第二个数，则交换两个数，否则直接输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int main()
{
	int a,b;
	printf("请输入两个数字\n");
	scanf("%d%d", &a, &b);
	if(a<b) swap(&a, &b);
	printf("%d, %d\n", a, b);
    return 0;
}

void swap(int *p, int *q)
{
	int temp;
	temp = *p;
	*p = *q;
	*q = temp;
}

数组函数参数

1
2
3
4
5
6
7
8
int a[] == int *a;
int a[N] == int *a;

int a[N][4] = int (*a)[4];
int a[][4] = int (*a)[4];

int *a[N] == int *a;
int *a[] == int *a;
1
2
3
4
5
6
7
8
9
10
11
12
13
int main()
{
	double d[3] = {1.1, 2.2, 4.3};
	fun_add(d);
	printf("%f\n", d[2]);
}

void fun_add(double *p)
{
	p[1] = p[0] + p[2];
	// 上面一行代码与下一行相同
	//*(p+1) = *p + *(p+2);
}

函数的指针

字符串的指针

字符串结尾会有\0来标识当前字符串的结束

初值个数不得超过数组大小

1
char ch[20] = "HelloWorld";

以char *型指针变量保存字符串首地址

1
2
3
4
5
6
7
8
9
char *ps = "iPhone";
// 只是将ps的指向地址改变，而不保存字符串内容本身。
ps = "iPad";

char s[] = "iTouch";
// 可以
ps = s;
// 错误，s的值不可以改变
s = "iMac";

字符串的输入输出

printf(“%s”, 一级地址);

其含义时从改地址开始逐个字符输出，直到遇到'\0'为止（\0不输出，也不自动换行）

输出字符串其他略有不同，后面要接地址，而不是直接接数据

1
2
3
4
printf("%d", 数据);
printf("%c", 数据);
printf("%f", 数据);
printf("%s", 地址);

puts(一级地址)

其含义是从地址开始逐个字符输出，直至\0为止（\0不输出）；然后自动换行（即最后再多输出一个'\n'）

1
2
3
puts(ps);
// 相当于
printf("%s\n", ps);

scanf(“%s”, 一级地址)

其含义是：读入键盘键入的一个字符串（最后要键入回车表示结束，但不键入’\0’），存入“一级地址”开始的一顿内存空间（回车符不存入），并自动在最后一个字符的后面添加'\0'。

如果字符串中含有空格或Tab符，只能读入空格或Tab符之前的部分（不读空格和Tab符）。

1
2
3
4
5
char a[30];
scanf("%s", a);
printf("%s", a);
// 此时输入 how are you? <回车>
// 只会输出 how

gets(一级地址)

其含义是：读入从键盘键入的一行字符（最后一定要键入回车表示结束，但不键入'\0'，存入“一级地址”开始的一顿内存空间（回车符不存入），并自动在最后一个字符的后面添加'\0'。如果字符串中含有空格、Tab符也一起读入并不中断。）

1
2
3
4
5
char b[30];
scanf("%s", b);
printf("%s", b);
// 此时输入 how are you? <回车>
// 会整句输出

字符串处理（常用套路）

数组法

1
2
3
4
5
6
7
// 第一种
for(i=0; s[i]!='\0'; i++)
    printf(s[i]);

// 或者
for(i=0; s[i];i++)
	printf(s[i]);

指针法

1
2
3
4
5
6
7
char *p;
p = 字符串起始地址;
while(*p != '\0')
{
    用*p访问或处理每个字符;
    p++;	//使p指向字符串的下一个字符
}

'\0'和末尾字符定位

让p指向字符串的最后一个字符

1
2
3
while(*p)
	p++;
p--;

字符串的连接

1
2
3
4
5
6
7
8
9
10
11
12
13
char s1[20] = "Hello";
char s2[] = "World";
char *ps1 = s1;
while(*ps1) ps1++;

char *ps2 = s2;
while(*ps2)
{
    *ps1 = *ps2;
    ps1++;
    ps2++;
}
*ps1='\0';

字符串倒序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void reverse(char *s)
{
    char *p, *q, t;
    
    while(*q) q--;
    
    while(*p)
    {
        t = *q;
        *q = *p;
        *p = t;
        p++;q++;
    }
}

int main()
{
    char st[80];
    scanf("%s", st);
    printf("正序： %s", st);
    reverse(st);
    printf("倒序： %s", st);
}

常用字符串函数

使用以下函数要包含头文件 #include <string.h>

函数含义功能详细说明
strlen(地址)求字符串长度函数返回值为字符串的长度，即从地址开始到’\0’的字符个数（不计’\0’，但其中空格、Tab符、回车符等都计数）
strcat(串1地址, 串2地址)字符串连接 “串1=串1+串2”把从串2地址开始到’\0’的内容，连接到串1的后面（删去串1最后的’\0’），结果仍存入串1地址开始的空间中，并在结果字符串末尾自动添加新’\0’（串1地址的空间应足够大）
strcpy(串1地址, 串2地址)字符串拷贝 “串1=串2”把从串2地址开始到’\0’的内容，拷贝到串1地址开始的空间中，’\0’也一同拷贝（串1地址的空间应足够大）
strcmp(串1地址, 串2地址)字符串比较 “串1>串2” “串1<串2” “串1==串2”两个字符串的大小结果由函数返回值说明： 若函数返回值 > 0，说明 串1 > 串2 若函数返回值 < 0，说明 串1 < 串2 若函数返回值 == 0，说明 串1 = = 串2

sizeof

求占用多少字节，结果为整数

sizeof 是运算符，不是函数，同时也是关键字

sizeof(类型 或表达式)

常用字符函数

需要包含头文件 #include <ctype.h>

isalpha(ch)检查ch是否为字母字符，是返回1，否返回0
isdigit(ch)检查ch是否为数字字符，是返回1，否返回0
isspace(ch)检查ch是否为空白分隔符，即是否为空格、跳格(Tab, ‘\t’)、换行符(‘\n’)、回车符(‘\r’)、换页符(‘\f’)5种之一。 如是这些字符返回1，否则返回0
islower(ch)检查ch是否为小写字母字符，是返回1，否返回0
isupper(ch)检查ch是否为大写字母字符，是返回1，否返回0
tolower(ch)将ch转换为小写字母，函数返回转换后的字符
toupper(ch)将ch转换为大写字母，函数返回转换后的字符