微信小程序+scala+linux内容笔记解析

Component({
  lifetimes: {
    attached() {    //组件实例进入页面节点树时执行
      console.log("acctached")
    }, 
    created() {
      console.log("created")
    }, 
  },

1.2.pageLifetimes节点

组件所在页面的生命周期函数，需要定义在pageLifetimes节点中，如下：

pageLifetimes: {
  show: function(){ console.log('show') }, //页面被展示
  hide: function(){ console.log('hide') }, //页面被隐藏
  resize: function(size){ console.log('resize') } //页面尺寸变化
},

2.插槽

2.1.单个插槽

在小程序中，默认每个自定义组件中只允许使用一个 <slot>进行占位，这种个数上的限制叫做单个插槽

<!--组件封装者-->
<view>
  <view>这里是组件内部节点</view>
  <slot></slot>
</view>

<!-- 组件使用者 -->
<my-text01>
  <view>这里是插入slot中内容</view>
</my-text01>

2.2.启用多插槽

启用多插槽需要在.js文件中开启如下代码：

options: {
  multipleSlots: true //在组件定义时的选项中启用多slot支持
},

区分多个slot节点可以使用name设置，代码如下：

<view>
  <slot name="before"></slot>
  <view>这里是组件内部节点</view>
  <slot name="after"></slot>
</view>

<my-text01>
  <view slot="after"> after</view>
  <view>这里是插入slot中内容</view>
  <view slot="before"> before</view>
</my-text01>

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

今天学习了一点的微信小程序开发，然后学习了Liunx内容；对于微信小程序而言，今天只是学习了一些组件的节点使用，就好比是生命周期的运行一样，只有特定时间才会触发；对于Liunx内容，今天只是了解了一下Liunx的发展史，即Liunx的由来；然后学习了Liunx系统的安装，以及对应Liunx系统配套的远程操控软件，在公司中，一般无法直接对Liunx进行操作，而是通过远程的手段去操作Liunx，因此这是必要的，然后就复习了一下Liunx的vi以及vim命令的使用，总体来说今天学习的暂时是可以的，还没问题

日期：10月9日 Liunx常用指令

尚硅谷Linux教程：尚硅谷Linux教程(千万级学习人次，好评如潮)_哔哩哔哩_bilibili

1.今天所学内容摘要：

1.常用命令

1.1.vim

拷贝当前行 yy，拷贝当前行向下的5行 5yy，并粘贴。
删除当前行 dd ，删除当前行向下的 5行 5dd
在文件中查找某个单词 [命令行下关键字，回车查找，输入 n 就是查找下一个]
设置文件的行号，取消文件的行号.[命令行下 :set nu 和 :set nonu]
编辑 /etc/profile 文件，使用快捷键到底文档的最末行[G]和最首行[gg]
在一个文件中输入“hel1o”然后又撤销这个动作 u
编辑 /etc/profile 文件，并将光标移动到 20行 shift+g

1.2.关机&重启命令

shtudown
    shutdown -h now : 立即关机
    shutdown -h 1 : 1分钟后关机
    shutdown -r now : 立即重启
halt : 关机
reboot : 重启
sync    : 同步内存数据到磁盘

注意：当我们关机或重启前，都应该执行 sync 指令，将内存数据写入磁盘保存，防止数据丢失。

1.3.添加、删除、查询用户

添加

useradd -d 指定目录用户名 : 给新建用户指定家目录

删除

userdel 用户名 : 删除用户，但是保留家目录

userdel -r 用户名 : 删除用户以及用户主目录

查询

id 用户名 ：查询用户信息

whoam : 查看当前登录用户

切换

su - 用户名 ：切换用户名 返回上一个登录的用户 exit

注意：在实际应用中，一般保留家目录

1.4.用户组

添加组 : groupadd 组名

删除组 : groupdel 组名

给用户分配组： useradd -g 用户组用户名

修改用户组：usermod -g 用户组用户名

用户和组的相关文件
/etc/passwd
    用户的配置文件，记录用户的各种信息
    每行含义：用户名：口令：用户标识号：组标识号：注释性描述：主目录：登录shell
/etc/shadow
    口令的配置文件
    每行含义：登录名:加密口令:最后一次修改时间:最小时间间隔:最大时间间隔:不活动时    间:失效时间:标志
/etc/group
    组的配置文件，记录Linux包含的组的信息
    每行含义：组名：口令：组标识号：组内用户列表

2.实用指令

2.1.指定运行级别

小技巧：当密码忘记时可以通过修改级别为 1 进入系统，后续通过passwd修改密码

2.2. >指令和 >>指令

">" 重定向 ">>" 追加

基本语法：

ls -l > 文件 (功能描述:列表的内容写入文件a.txt中(覆盖写))
ls -al >> 文件 (功能描述:列表的内容追加到文件aa.txt的末尾)
cat 文件1 >> 文件2 (功能描述:将文件1的内容覆盖到文件2)
echo "内容" >> 文件 (书写内容追加到文件中)

2.3.echo指令

基本语法：

echo [选项] [输出内容]

案例：

echo $PATH 输出$PATH环境变量

echo "hello，word" 控制台输出hello，word语句

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

今天主要是Liunx的学习，包括常用指令以及实用指令的学习；但是今天的内容主要还是复习为主，因为今天学习的内容大都是我已经学习过的内容；对于vim的内容今天多学习了几个快捷方式；然后今天新学习了Liunx系统的关机，重启等命令；还有用户以及用户组之类的内容，大多对于文件类操作的命令以及学习过，因此不重复记笔记；对于今天学习内容重要的应该只有用户类的操作，毕竟以后自己只能以用户身份访问Liunx，不可能接触到Liunx主机。

日期：10月10日 Liunx文件，时间，权限，任务调度，分区类指令

尚硅谷Linux教程：尚硅谷Linux教程(千万级学习人次，好评如潮)_哔哩哔哩_bilibili

1.今天所学内容摘要：

1.文件目录类指令

1.1. ln指令类似Windows里的快捷方式

基本语法：

ln -s [源文件或目录] [软链接名] (功能描述：给源文件创建一个软链接)

删除软链接： rm -rf 软链接名

1.2. history指令查看历史命令或指令

基本语法：

history (功能描述：查看已经执行过历史命令)

注意：指令后可以跟数字，表示显示多少条历史命令；同时可以通过 !178 的形式执行历史命令

2.时间日期类指令

基本语法 date [OPTION]… [+FORMAT] 2）选项说明

-d<时间字符串> 显示指定的“时间字符串”表示的时间，而非当前时间

date -d ‘1 days ago’ （功能描述：显示前一天时间）
date -d ‘-1 days ago’ （功能描述：显示明天时间）

-s<日期时间> 设置系统日期时间

3）参数说明 <+日期时间格式> 指定显示时使用的日期时间格式

2.1.date 显示当前时间

（1）date （功能描述：显示当前时间）（2）date +%Y （功能描述：显示当前年份）（3）date +%m （功能描述：显示当前月份）（4）date +%d （功能描述：显示当前是哪一天）（5）date "+%Y-%m-%d %H:%M:%S" （功能描述：显示年月日时分秒）

2.2. cal 查看日历

基本语法：

cal [选项] （功能描述：不加选项，显示本月日历）

查看 2017 年的日历： cal 2023

3.组管理和权限管理

3.1. 文件/目录所有者所在组

指令： ls -ahl 查看文件的所有者

指令： chown 用户名文件名修改文件拥有者

-R 用户名目录名修改目录及目录内所有文件拥有者

指令： chgrp 组名文件名修改文件所在组

-R 用户名目录名修改目录及目录内所有文件的所有组

3.2. 权限基本介绍

-rwxrw-r-- 1 root root 1213 Feb 2 09:39 abc
第一个字符代表文件类型: 文件(-),目录(d),链接(i)

其余字符每3个一组(rwx) 读(r)写(w)执行(x)

第一组rwx: 文件拥有者的权限是读、写和执行

第二组rw-: 与文件拥有者同一组的用户的权限是读、写但不能执行

第三组r--: 不与文件拥有者同组的其他用户的权限是读不能写和执行

可用数字表示为:r=4,w=2,x=1 因此rwx=4+2+1=7
1					文件： 硬链接数 或 目录： 子目录数
root				用户
root				组
1213				文件大小（字节） 若是文件夹则4096
Feb 2 09：39			最后修改日期
abc					文件名

3.3. 修改权限 chmod

基本说明：

通过chmod指令，可以修改文件或目录的权限

第一种方式: + 、- 、= 变更权限

u：所有者 g：所有组 o：其他人 a：所有人(u、g、o的总和)

chmod u=rwx，g=rx，o=x 文件目录名
chmod o+w 文件目录名
chmod a-x 文件目录名

4.crond 任务调度

重新启动 crond 服务： systemctl restart crond

4.1. crontab 定时任务设置

基本语法：

crontab [选项]

选项说明：

-e 编辑 crontab 定时任务

每隔 1 分钟，向/root/bailongma.txt 文件中添加一个 11 的数字
*/1 * * * * /bin/echo ”11” >> /root/bailongma.txt

项目 含义 范围
第一个* 一小时当中的第几分钟 0-59

第二个* 一天当中的第几小时 0-23

第三个* 一个月当中的第几天 1-31

第四个* 一年当中的第几月 1-12

第五个* 一周当中的星期几 0-7 （ 0 和 7 都 代 表 星 期日）
--------------------------------------------------------------------------------
特殊符号 含义
* 代表任何时间。比如第一个 * 就代表一小时中每分钟都执行一次的意思。

，代表不连续的时间。比如“0 8,12,16 * * * 命令”，代表每天 8点0分，12点0分，16点0分都执行一次命令

- 代表连续的时间范围。比如“0 5 * * 1-6 命令”，代表在周一到周六的凌晨 5点0分执行命令

*/n 代表每隔多久执行一次。比如“*/10 * * * * 命令”，代表每隔 10 分钟就执行一遍命令

-l 查询 crontab 任务

-r 删除当前用户所有的 crontab 任务

service crond restart [重启任务调度]

5.Linux分区

5.1. 硬盘说明

查看所有设备挂载情况： lsblk lsblk -f

12.2.2 硬盘说明

1)Linux 硬盘分IDE 硬盘和 SCSI硬盘，目前基本上是 SCSI硬盘

2)对于IDE硬盘，驱动器标识符为 “hdx~” 其中 hd 表明分区所在设备的类型，这里是指IDE硬盘了。“x”为盘号(a为基本盘，b为基本从属盘，c为辅助主盘，d为辅助从属盘), ~ 代表分区前四个分区用数字1到4表示，它们是主分区或扩展分区，从5开始就是逻辑分区。例，hda3 表示为第一个IDE硬盘上的第三个主分区或扩展分区hdb2表示为第二个IDE 硬盘上的第二个主分区或扩展分区。

3)对于 SCSI硬盘则标识为“sdx~”，SCSI硬盘是用“sd”来表示分区所在设备的类型的，其余则和 IDE 硬盘的表示方法一样。

5.2. 虚拟机增加硬盘

在[虚拟机]菜单中，选择[设置]，然后设备列表里添加硬盘，然后一路[下一步]，中间只有选择磁盘大小的地方需要修改，至到完成。然后重启系统(才能识别)!

分区命令 fdisk /dev/sdb
开始对/sdb分区
	m	显示命令列表
	p	显示磁盘分区 同 fdisk -l
	n	新增分区
	d	删除分区
	w	写入并退出
说明: 开始分区后输入n，新增分区，然后选择 p ，分区类型为主分区。两次回车默认剩余全部空间。最后输入 w 写入分区并退出，若不保存退出输入 q。

格式化磁盘分区命令：mkfs -t ext4 /dev/sdb1 其中ext4是分区类型
挂载: 将一个分区与一个目录联系起来，
- mount 设备名称挂载目录
  - 例: mount /dev/sdb1 /newdisk
- umount 设备名称或者挂载目录
  - 例如: umount /dev/sdb1 或者 umount /newdisk
- 用命令行进行挂载，在重启后挂载会失效
永久挂载：通过修改 /etc/fstab 实现挂载；添加完成后执行 mount -a 即刻生效

5.3. 磁盘情况查询

df -lh ：查询系统整体磁盘使用情况

du -h /目录：查询指定目录的磁盘占用情况

-s 指定目录占用大小汇总
-h 带计量单位
-a 含文件
--max-depth=1 子目录深度
-c 列出明细的同时，增加汇总值

5.4. 磁盘情况 - 工作实用指令

ls -l /home | grep "^-" | wc -l ：统计/home文件夹下文件个数

ls -l /home | grep "^d" | wc -l ：统计/home文件夹下目录个数

ls -lR /home | grep "^-" | wc -l ：统计/home文件夹下文件个数，包括子文件夹中的

ls -lR /home | grep "^d" | wc -l ：统计/home文件夹下目录个数，包括子文件夹中的

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

今天了解了Liunx中针对于文件，时间，权限，以及分区，定时任务等内容的知识；对于文件类指令单纯的就学习了如何创建快捷方式，如何查看历史命令等；对于时间类，学习了查看修改日期时间，查看日历；对于权限的学习，学习了文件权限的划分，以及如何改变该文件的权限，如何改变该文件的所在组，所拥有者等；其次学习了定时任务的内容，很简单，主要要学会编写脚本；最后了解了Liunx分区，以及如何添加磁盘的操作；今天学习还算ok，没说明难点；

日期：10月11日 Liunx的网络配置、进程/服务管理，RPM与YUM下载

尚硅谷Linux教程：尚硅谷Linux教程(千万级学习人次，好评如潮)_哔哩哔哩_bilibili

1.今天所学内容摘要：

1.网络配置

在网络配置中主要要了解网络的流程图；然后学习如何配置Liunx系统的IP地址设置，IP的自启动以及固定IP的设置；但是在Liunx系统中我们一般都是使用的固定IP地址，因为Liunx系统通常作为服务器使用

对于本机网络状态则需要学习如何监控网络状态

1.1. Liunx 网络配置原理图（含虚拟机）

vim /etc/sysconfig/network-scripts/ifcfg-ens33 ：配置固定IP

1.2. 监控网络状态

基本语法：

netstat [选项]
-an	按一定顺序排列输出
-p	显示哪个进程在调用

案例：查看服务名为sshd的网络服务信息
netstat -anp | grep sshd

2.进程管理

进程：计算机中，一个正在执行的程序或命令

对于进程这一块内容我们主要要学习如何查看进程，如何对进程进行操作

对于进程的查看，不只有ps还有top，两者是类似的，但是top在执行一段时间可以更新正在运行的进程，因此被叫做动态监控进程

2.1. 显示系统执行的进程

ps ：查看目前系统中，正在执行的程序，且执行的状况

-a：显示当前终端的所有进程信息
-e：显示所有进程
-f：全格式
-u：以用户的格式显示进程信息
-x：显示后台进程运行的参数

2.2. 终止进程 Kill 和 Killall

kill [选项] 进程号：通过进程号杀死进程

-9 进程号：强制杀死进程

killall 进程名称：通过进程名称杀死进程，支持通配符

2.3. 查看进程树 pstree

pstree -p ：显示进程的PID

pstree -u ：显示进程的所属用户

2.4.动态监控进程

动态监控进程是指在查看进程的同时，可以实时更新正在运行的进程

基本语法：

top [选项]
-d 秒数 ： 指定top命令每隔几秒更新，默认为3秒
	在top命令的交互模式中可以执行一下操作：
		p	以CPU使用率排序
		M	以内存使用率排序
		N	以PID排序
		Q	退出top
-i	：	使top不显示任何闲置或僵死进程
-p	：	通过指定监控进程ID来监控某个进程的状态

3.服务管理

服务：启动之后，常驻内存的进程

在服务这一块内容中，需要了解服务的查看方式，如何对服务进行操作，其次要学习系统的运行级别，以及对每个不同服务的系统运行级别如何进行操作

3.1. systemctl管理命令

小技巧：当我们需要查看当前端口是否被监听时，可以通过windows终端输入：telnet 192.168.56.101 22的方式验证

基本语法:

systemctl start|stop|restart|status [服务名]

查看服务名的方法：cd /usr/lib/systemd/

查看当前运行级别： systemctl get-default

multi-user.target：等价于原运行级别3（多用户有网，无图形界面）
graphical.target：等价于原运行级别5（多用户有网，有图形界面）

修改当前运行级别

## TARGET 取 multi-user 或者 graphical
systemctl set-default [TARGET].target

A. systemctl 设置服务的自启动状态

systemctl list-unit-files [ | grep 服务名] 		  (查看服务开机启动状态)
systemctl enable 服务名 							(设置服务开机启动)
systemctl disable 服务名 							(关闭服务开机启动)
systemctl is-enabled 服务名 						(查询某个服务是否是自启动的)

3.2.chkconfig指令

chkconfig命令用于给每个服务各个运行级别设置自启动/关闭

使用细节：chkconfig重新设置服务后自启动或关闭，需要重启才能生效

基本语法：

1. 查看所有服务 chkconfig --list
2. 查看指定服务 （如防火墙）
	chkconfig --list | grep iptables(防火墙)
	chkconfig iptables --list
3. 修改指定服务运行级别为自启动 on /关闭 off （如sshd）
	chkconfig --level 5 sshd on

4.RPM 与 YUM

RPM：一种用于互联网下载包的打包及安装工具，它生成具有.RPM扩展名的文件，类似于windows的setup.exe

在RPM的删除操作中需要注意一个细节：当需要删除软件包存在依赖时，是无法正常删除的，除非使用 rpm -e --nodeps 软件包名 进行强制删除，但是一般不建议使用强制删除

YUM：一个shell前端软件包管理器，能够从指定的服务器自动下载RPM包并且安装，可以 自动处理依赖性关系，并且一次安装所有依赖的软件包

4.1.RPM基本语法：

查询类指令

rpm -qa	：	查询所安装的所有rpm软件包
rpm -qa | grep firefox	：	查询是否安装火狐浏览器
rpm -qi 软件包名	：	查询软件包信息
rpm -ql 软件包名	:	查询rpm包的文件安装到哪里去了
rpm -qf 文件全路径名	：	查询文件所属的软件包

操作类指令

##	删除rpm包
rpm -e 软件包名
##	安装rpm包
rpm -ivh 软件包全路径名称		【i 安装	v 提示	h 进度条】

4.2.YUM基本语法：

查询类指令

##	查询yum服务器是否有需要安装的软件
yum list | grep xxx

操作类指令

##	安装指定的yum包
yum install xxx

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

对于网络配置的内容，没什么重难点；常用的只有进程，服务，以及下载软件，查找软件等内容；对于进程的管理也没有难点，主要就是进程的查看以及杀死；对于服务的管理比较重要，在Liunx中对于软件的启动挂起等操作都可以被当作服务来看待，例如防火墙的挂起以及启动就需要依靠服务管理来解决，在则对于服务的运行，还要了解服务在不同运行级别下的自启动模式；最后对于Liunx中的文件下载，软件下载都需要用到rpm命令以及yum命令，因此这也是一个要点，要熟练掌握两个命令的使用。

日期：10月12日 Liunx大数据定制篇 - Shell编程

尚硅谷Linux教程：尚硅谷Linux教程(千万级学习人次，好评如潮)_哔哩哔哩_bilibili

1.今天所学内容摘要：

1.1. 大数据定制篇 - Shell编程

为什么学习Shell编程，什么是Shell；

Shel是一个命令行解释器，提供了一个向Linux内核发送请求以便运行程序的 界面系统级程序，可以用Shell来启动、挂起、停止甚至是编写一些程序。

通过Shell程序可以进行服务器的管理

通过Shell脚本可以进行程序或是服务器的维护，如一个定时备份数据库的脚本

通过Shell程序管理集群

1.1.1. Shell脚本的执行方式

A. 脚本格式要求：

a. 脚本以 #!/bin/bash 开头： Shell脚本用 bash 进行解析

b. 脚本需要可执行权限

B. 编写一个Shell脚本案例：

a. 创建Shell脚本，输出 hello world！

#!/bin/bash echo "hello world!"

C. 脚本常用执行方式

a. 输入脚本的绝对路径或相对路径

./myShell.sh

/root/shell/myShell.sh

b. sh + 脚本路径

不用赋予x可执行权限，也能执行（不推荐）

1.1.2. shell变量的定义

Linux shell中的变量分为，系统变量和用户自定义变量。

显示当前shell中所有变量: set

A. 基本语法：

a. 定义变量：变量 = 值

A = 100 echo "A = $A"

b. 撤销变量： unset 变量

c. 声明静态变量： readonly 变量，注意：不能unset

B. 变量定义规则：

变量名称可以由字母、数字和下划线组成，但是不能以数字开头

等号两侧不能有空格

变量名称一般惯为

C. 将命令的返回值赋予变量（重点）

A = `ls -al` 反引号 ，运行里面命令，将返回值赋予A
A = $(ls - al) 等价于上一条命令

1.1.3. 配置环境变量

export 变量名=变量值 (功能描述:将she11变量输出为环境变量)

source 配置文件 (功能描述:让修改后的配置信息立即生效)

echo $变量名 (功能描述:查询环境变量的值)

A. 在/etc/profile 文件中定义 TOMCAT_HOME环境变量

TOMCAT_HOME=/opt/tomcat
export TOMCAT_HOME

注意：在定义好变量后，需要使用 source /etc/profile 立即启用配置

B. 查看环境变量 TOMCAT_HOME 的值

echo $TOMCAT_HOME

C. 在另外一个Shell程序中使用 TOMCAT_HOME

echo "tomcat=$TOMCAT_HOME"

1.1.4. 位置参数变量

当我们执行一个 shell 脚本时，如果希望获取到命令行的参数信息，就可以使用到位置参数变量，比如 :./myshellsh 100 200，这个就是一个执行 she1 的命令行，可以在mshell 脚本中获取到参数信息

A. 基本语法：

$n				(功能描述:n为数字，$0代表命令本身，$1-$9 代表第一到第九个参数，十以上的参数，十以上的参数需要用大括号包含，如${10})
$*				(功能描述:这个变量代表命令行中所有的参数，$*把所有的参数看成一个整体)
$@				(功能描述:这个变量也代表命令行中所有的参数，不过$@把每个参数区分对待)
$#				(功能描述:这个变量代表命令行中所有参数的个数)

B. 位置参数变量案例：

案例：positionPara.sh在脚本中获取到命令行的各个参数信息编写一个 shel1 脚本

#!/bin/bash
echo "$0 $1 $2"	
echo "$*"
echo "$@"
echo "参数个数=$#"

1.1.5. 预定义变量

shel1 设计者事先已经定义好的变量，可以直接在 she1 脚本中使用

A. 基本语法：

使用技巧：在Shell中后台运行某程序用 ./shell.sh &

$$						(当前进程的进程号(PID))
$!						(后台运行的最后一个进程的进程号(PID))
$?						(最后一次执行的命令的返回状态。如果这个变量的值为 0，证明上一个命令正确执行;如果这个变量的值为非 0(具体是哪个数，由命令自己来决定)，则证明上一个命令执行不正确了。)

1.1.6. 自定义函数

A. 基本语法：

#案例1：计算输入的参数的和 (read) , getSum
function getSum()
{
        SUM=$[$n1+$n2]
        echo "和是$SUM"  
}

read -t 10 -p "请输入第一个数n1：" n1
read -t 10 -p "请输入第一个数n2：" n2

getSum $n1 $n2

B. 综合案例：

定时备份数据

#!/bin/bash
#备份路径
BACKUP=/root/shell/shellDown0
#当前时间为文件名
DATETIME=$( date +%Y_%m_%d_%H%M%S )
echo "==========开始备份============="
echo "==========备份路径是 $BACKUP/$DATETIME.tar.gz"
#创建备份的路径
#如果备份路径文件夹存在，就使用，否则创建
[ ! -d "$BACKUP/$DATETIME" ] && mkdir -p "$BACKUP/$DATETIME"
#执行备份数据的指令
echo "$date" > $BACKUP/$DATETIME/$DATETIME.txt
#打包备份文件
cd $BACKUP
tar -zcvf $DATETIME.tar.gz $DATETIME
#删除临时目录
rm -rf $BACKUP/$DATETIME
#删除10天前的备份文件
find $BACKUP -mtime +10 -name "*.tar.gz" -exec rm -rf {} \;
#备份完成
echo "==============备份完成啦================="

1.2. Python 定制篇 - 开发平台 Ubunt

安装ubuntu 成功后，都是普通用户权限，并没有最高root限，如果需要使用root 权限的时候通常都会在命令前面加上 sudo 。有的时候感觉很麻烦我们一般使用 su 命今来直接切换到root用户的 , 但是如果没有给root设置初始密码就会抛出 su：Authentication failure 这样的问题。

小技巧：Ubuntu的默认软件下载位置在国外，因此我们需要修改它的软件下载地址 使用清华大学开源软件镜像站，同时源文件需要备份，替换好后需要进行更新源操作

1.2.1. APT软件管理

A. Ubuntu软件操作的相关命令

#	sudo apt-get update 更新源
#	sudo apt-get install package 安装包
#	sudo apt-get remove package 删除包

sudo apt-cache search package 搜索软件包
#	sudo apt-cache show package 获取包的相关信息，如说明、大小、版本等
sudo apt-get install package --reinstall 重新安装包

sudo apt-get -finstall 修复安装
sudo apt-get remove package --purge 删除包，包括配置文件等
sudo apt-get build-dep package 安装相关的编译环境

sudo apt-get upgrade 更新已安装的包
sudo apt-get dist-upgrade 升级系统
sudo apt-cache depends package 了解使用该包依赖那些包
sudo apt-cache rdepends package 查看该包被哪些包依赖
#	sudo apt-get source package 下载该包的源代码

1.2.2. SSH远程登录

Ubuntu的sshd不同于centos，是需要自己安装配置的，对于ssh的配置要注意的就是需要先用systemctl enable ssh.service命令去启动这个服务，然后才能执行sshd的是service服务启动命令，否则会报错说找不到服务。

A. 安装SSH和启用

sudo apt-get install openssh-server

service sshd start

2.所遇到的问题描述：

2.1. 报错：tar压缩文件时未指定压缩的文件；tar压缩文件时压缩名内不能有：

2.2.报错：sshd启动失败，翻译后了解是为找到sshd服务，判断可能是服务未开启

A.解决方法：

解决方案：
启用ssh.service
systemctl enable ssh.service
启动ssh
service sshd start

3.扩展学习部分：

3.1《Centos系统——shell脚本判断语句》_centos7.6 shell if判断-CSDN博客

应用场景：编写服务的启动脚本

3.2linux-centos-shell循环语句及函数OR数组详解_shell or-CSDN博客

应用场景：批量添加用户，根据IP地址检查主机状态

3.3【shell编程---控制台输入，函数】_shell 控制台输入-CSDN博客

4.学习总结：

Shell的编程开发总体来讲走的就是一个脚本，自动化流程；对于shell脚本的编写主要需要要了解shell的变量、shell的函数、shell中的语法格式等内容即可，同时shell脚本的自动化需要兼用任务定时调节的crond命令完成；Ubuntu的基础配置还是可以的，但是在配置sshd时会出现问题，不过Ubuntu总体来说还是类似于centos7的因此不算太大问题。

日期：10月16日 Scala数据类型、变量

尚硅谷大数据技术之Scala入门到精通教程（小白快速上手scala）哔哩哔哩bilibili

1.今天所学内容摘要：

数据分析解剖里截图

1.1.Scala 数据类型

Scala的数据类型和Java差不多，但是Scala中一切数据都是对象，都是Any的子类，Scala中数据类型分为两大类：数值类型（AnyVal），引用类型（AnyRef）；Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）；在Scala中并没有void，而是用Unit代替，Unit也是数据类型，且只有一个对象（）。在Scala中Null表示一个类型，只有一个对象null，且它是所有引用类型的子类；再则在Scala中通常需要刻意将异常抛出返回时会使用Nothing接收

A.Unit 类型、 Null 类型和 Nothing 类型（重点）

基本说明

类型	描述
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null , Null 类型只有一个实例值null
Nothing	Nothing类型在Scala的类层级最低端；它是任何其他类型的子类型。当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）

案例实操

(1)Unit 类型用来标识过程，也就是没有明确返回值的函数。
object TestSpecialType {
	def main(args: Array[String]): Unit = {
		def sayOk : Unit = {// unit 表示没有返回值，即 void
		println(sayOk)
	}
}
(2)Null 类只有一个实例对象， Null 类似于 Java 中的 null 引用。 Null 可以赋值给任意引用类型（ AnyRef ），但是不能赋值给值类型 AnyVal
object TestDataType {
	def main(args: Array[String]): Unit = {
	//null 可以赋值给任意引用类型（ AnyRef ），但是不能赋值给值类型AnyVal
	var cat = new Cat();
	cat = null // 正确
	var n1: Int = null // 错误
	println("n1:" + n1)
	}
}
class Cat {}
(3) Nothing ，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。
object TestSpecialType {
	def main(args: Array[String]): Nothing = {
		throw new Exception()
	}
}

1.2.scala 数据变量

1、定义: val / var 变量名:变量类型 = 值 2、val与var的区别: val定义的变量不可用被重新赋值,类似java的final var定义的变量可以被重新赋值

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

今天主要就学习了Scala的基础语法，数据类型，数据变量等内容；总体来说Scala的数据类型类似java，但是它的数据类型全是面向对象式的，而且Scala中对数据类型之间的规定是很严谨的，例如在Scala中null虽然代表空，但是并不能赋予所有数据类型，Null 可以赋值给任意引用类型（ AnyRef ），但是不能赋值给值类型 AnyVal；Scala的数据变量到是有点js中的样子，又有点python中的样子；这部分内容中主要还是要注意scala中的数据类型，在Scala的后续学习中数据类型很重要！

日期：10月17日 Scala运算符、基础判断循环语句、基础函数内容

尚硅谷大数据技术之Scala入门到精通教程（小白快速上手scala）哔哩哔哩bilibili

1.今天所学内容摘要：

1.1.基础判断、循环语句

Scala程序代码和所有编程语言代码一样，都会有特定的执行流程顺序，默认情况下是顺序执行，上一条逻辑执行完成后才会执行下一条逻辑，执行期间也可以根据某些条件执行不同的分支逻辑代码。

A.分支控制（条件判断if）

Scala中的条件判断语句其实是类似与Java的，但是Scala更加讲究精简，因此Scala的条件判断语句大都是可以缩略的写的

if(布尔表达式) {
	// 如果布尔表达式为 true 则执行该语句块
}

注意：当if的逻辑代码只有一行时可以省略{}

B.循环控制（for语句）

Scala的循环可以说是Java的增强版，大致语法思路类似，但是结构的样式不同，且scala的for循环支持在赋值处添加条件判断语句，相比Java，Scala则是更加严谨，直接在for循环的时候就将对应不满足条件的值给省略；scala是完全面向对象的语言，所以无法使用break，continue关键字这样的方式来中断，或继续循环逻辑，而是采用了函数式编程的方式代替了循环语法中的break和continue，使用面向对象的方式来代替，采用抛出异常的方式来跳出循环

1）循环返回值
//ield关键字：把每一次的返回结果都保存下来
val result = for ( i <- Range(1,5) ) yield { i * 2 }
//Java中的线程有yield方法，Scala中使用Thread.yield调用

2)循环守卫
//循环时可以增加条件来决定是否继续循环体的执行，这里的判断条件称之为循环守卫
for ( i <- Range(1,5) if i != 3  ) { println("i = " + i ) }

3)循环中断
Breaks.breakable{
      for(i <- 1 to 5){
        if(i == 3){
          Breaks.break()
        }
        println(i)
      }
    }
    println("other")
  }

1.2.基础函数

在这一章中首先要分清函数与方法的区别：定义函数最常用的方式是作为某个对象的成员。这样的函数被称为方法；在Scala中函数和方法几乎可以等同(定义、使用、运行机制都是一样的)，只是函数的使用方式更加灵活；Scala中函数是一等公民，像变量一样，既可以作为函数的参数使用，也可以将函数赋值给一个变量。函数的创建不需要依赖对象或者类，而在java中，函数的创建需要依赖类或者接口等。

A.函数的定义

def 函数名([参数名: 参数类型],...) [: 返回值类型] = {
 	语句
 	[return] 返回值
}

B.函数基本使用案例

1)求两数相加
def add(age: Int, age1: Int): Int = {
    println(age + age1)
}
2)化简
def add(age: Int, age1: Int) = println(age + age1)

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

无论是Java也好Scala也好；两者之间总是有联系在的，其次Scala更加像是Pyhton与Java的拼凑版，又或者是Python就是简洁的Scala；Scala的判断语句是Java的类型，Scala的for循环是强化版的java，可以说学习起来不会有大问题，主要是Scala喜欢极度的去精简一些语句，精简到只有特殊符号未知，实在是可读性不高，而且Scala的数据类型之间联系读很高，不能出现差错式的编程。

日期：10月18日 Scala 匿名函数、闭包、柯里化、递归、控制抽象、惰性加载、面向对象基础

尚硅谷大数据技术之Scala入门到精通教程（小白快速上手scala）哔哩哔哩bilibili

1.今天所学内容摘要：

匿名函数：省略函数名，能简便就简便的一种函数写法，但匿名函数本质上算是一个表达式；箭头左边是参数列表，右边是函数体
(x: Int, y: Int) => x*y
闭包：我个人觉得闭包就是函数里面套用了一个函数的形式，蛮好理解的
柯里化：将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。
def add(x:Int)(y:Int) => x + y
递归：递归就是在函数中调用函数本体，实现的轮回调用的形式而已，与java如出一辙 尾递归的核心思想：尾递归简单说就是将每次递归的结果值直接进行提取，赋值，然后每次递归都覆盖原值
//正常递归案例(阶乘)
def factorial(number: Int): Int = {
  if (number == 0) return 1
  factorial(number - 1) * number
}
//尾递归实现
def tailFact(n: Int): Int = {
  @tailrec
  def loop(n: Int, currRes: Int): Int = {
    if (n == 0) return currRes
    loop(n - 1,currRes * n)
  }
  loop(n,1)
}
惰性加载：Scala中使用关键字 lazy 来定义惰性变量,惰性变量只能是不可变变量，且只有当该变量被调用的时候才回去执行，不会在一开始时就初始化好

1.1.控制抽象

1）抽象控制是一个方法，但是方法的参数a是一个函数 2）函数a的没有参数，也没有返回值 主要目的：”在一个方法中调用某个代码块“ 也可一理解成 () => Uni t的匿名函数, 可以简写成 =>Unit

//代码块
def ff1():Int = {
  println("ff1方法被拿取")
  22
}
//抽象控制
def ff2(a: =>Int): Unit = {   //参数类型定义为特殊类型
  println("a = " + a)
}
ff2(ff1())   //将ff1的函数代码块整体当值传递

A.柯里化，递归，闭包，抽象整体案例

@tailrec
def myWhile3(condition: => Boolean)(op: =>Unit): Unit = {
  //内层函数需要递归调用，参数就是循环体
  if (condition) {
    op
    myWhile3(condition,op)
  }
}
myWhile3(n >=1,{
  println("n:" + n)
  n -= 1
})

1.2.Scala面向对象基础

这一部分基础内容没什么好说的，主要就是Scala中的构造器很特殊，相对于Java，Scalal主构造器与类是一体的

A.类的构造器

主构造器和类的声明放在一起，只能有一个主构造器，而辅助构造器可以有多个，使用关键字this实现。

class Student1() {
  var name: String = _
  var age: Int = _
  println("主构造器被调用")
  def this(name: String) {
    this()
    println("辅助构造器1被调用")
    this.name = name
    println(s"name: $name, age: $age")
  }
  def this(name: String, age: Int) {
    this(name)
    println("辅助构造器2被调用")
    this.age = age
    println(s"name: $name, age: $age")
  }
}

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

对于Scala中的语法类结构思路其实没有什么难点，不管语言怎么改变，实现对应事件的思想是不会变的；就比如闭包和递归，说到底就是对函数或方法的循环嵌套调用而已，再着的控制抽象就是将方法体内代码块当作值传递给另一个方法调用执行而已，实现思路就是不会先去执行函数体，而是将函数体打包进行传输，等抽象控制的函数体调用了传输进来的函数体，才会执行；Scala的面向对象原理其实也是类似Java的实现思路也差不多，所以不多表述了。

日期：10月19日 Scala继承、多态、抽象类、伴生对象、特质、类型检测和转换、枚举类和应用类

尚硅谷大数据技术之Scala入门到精通教程（小白快速上手scala）哔哩哔哩bilibili

1.今天所学内容摘要：

1.继承 class 子类名 extends 父类名 { 类体 } 继承的调用顺序：父类构造器->子类构造器，创建子类对象时层层依次调用继承相当于直接调用父类的主构造器，当父类的主构造器需要传参时，继承时就要传参

2.多态 Scala 中属性和方法都是动态绑定，而 Java 中只有方法为动态绑定。

3.抽象属性和抽象方法 如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类重写非抽象方法需要用 override 修饰，重写抽象方法则可以不加 override。子类中调用父类的方法使用 super 关键字

1.1.对象

使用object修饰的类都是静态类也可以理解成对象 ,里面的定义的内容都是静态的可以直接只用不需要new

1.1.1 伴生类和伴生对象

*条件 1：在同一个源文件中,* *条件 2：对象名和类名相同*

伴生对象和伴生类之间可以互相访问彼此的私有属性和私有方法

  *类名和object的名称一致
  * 类是对象的伴生类
  * 对象是类的伴生对象
class Demo6(val name: String) {
}
object Demo6 {
}

1.2.apply方法

使用此方法时，可以在main函数中不通过new来创建一个对象，即可以不用专门的一次一次地进行实例化，加载创建对象的这个类的时候，会自动调用apply这个方法，类似Java中的static静态块。建议将这个方法写在半生对象中 , 如果将这个方法写在一个没有半生对象的类中是无法使用的；通常我们会在类的伴生对象中定义apply方法，当遇到类名(参数1,...参数n)时apply方法会被调用

package chapter01

//构造方法私有化
class Test06 private(val name : String) {
  def printInfo(): Unit = {
    println(name + Test06.age)
  }
}
object Test06{
  val age : Int = 21
  def apply(name: String): Test06 = new Test06(name)   //特殊用法apply 使用apply命名后调用时可以直接省略不写
}
object Test66{
  def main(args: Array[String]): Unit = {
    val test06 = Test06("黄超群")
    test06.printInfo()
  }
}

注意:

apply方法的主要目的是不使用new来获取实例对象, 并且默认是单例的!!!!!
apply方法建议编写在伴生对象中
apply方法如果没有参数也不要省略()

1.3.特质

Trait(特质)相当于 java 的接口；特质中可以定义属性和抽象方法和方法的实现。

Scala 的类只能够继承单一父类，但是可以实现（继承，混入）多个特质（Trait）使用的关键字是 with 和 extends

注意：特质不能有主构造函数

1.3.1.特质多继承案例

注意：特质中当两个特质内有内容重复时，会有一种覆盖特性，即以最后的一个特性为标准

package chapter01
object Test07 {
  def main(args: Array[String]): Unit = {
    val test7777 = new Test7777
    test7777.ge()
    test7777.ye()
  }
}
abstract class Test77 {
  var age = 21
  def ge(): Unit
}
trait Test777 {
  val name = "孙燕敏"
  var sex = "男"
  def ye(): Unit
}
class Test7777 extends Test77 with Test777 {
  def ge(): Unit = {
    println(name,age,sex)
  }
  def ye(): Unit = {
    println(name,sex,age)
  }
}

1.3.2.特质的调用链

当有两个特质继承同一个特质，然后这两个特质又同时被人继承时，会触发特质调用链；当被调用时，会从最后一个特质的内容开始依次向上调用，直至调用到两个特质所都继承的特质为止。

package chapter01
object Test08 {
  def main(args: Array[String]): Unit = {
    val test88 = new Test88
    println(test88.acs())
  }
}
class Test88 extends sym with hcq{
  override def acs(): String = "这个:" + super.acs
}
trait chishi {
  def acs(): String = "爱吃fish"
}
trait hcq extends chishi {
  val name = "黄超群"
  override def acs(): String = name + "-" + super.acs
}
trait sym extends chishi {
  val event = "超级"
  override def acs(): String = event + "-" + super.acs
}

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

Scala中的面向对象思想是类似java的，但是却比涉及内容更多；Scala的继承不在划分为接口继承以及父类继承，而是统一化；其次Scala的抽象类更加简化，与java相比大相径庭；Scala最为特殊的还是伴生对象一内容，不过暂时还没明白到底有什么用处；特质就是接口的替代品，但特质的兼容性更好，可以书写的内容不局限于抽象方法；最后今天也是小小了解了一下Scala中的类型的强转以及枚举类的样式。

日期：10月23日 Scala数组、列表、set集合、map集合、元组

尚硅谷大数据技术之Scala入门到精通教程（小白快速上手scala）哔哩哔哩bilibili

1.今天所学内容摘要：

今天学习了集合中的五种类型；其次前四种类型都可以划分为 不可变 与可变；

不可变中所有类型都可以通过 ++ 将相同类型的数据相加到一起，反之可变中都可以用 ++= 的方式

数组与列表的不可变类型操作类似，都通过 +：与：+ 操作等，反之set集合则与map集合类似，使用 + 与 - 操作等

可变中的四种类型操作都是一致的都是通过 += 与 -= 进行操作等

1.1.map集合

在这一章节中，老师讲述的添加键值对方法是 += （”a“ , 1），但是按照scala中键值对的显示为（”a“ -> 1），因此我觉得添加键值对的方式理应为 += （”a“ -> 1），经过测试发现scala的语法确实是兼容这一做法的。

1.2.数组

数组的内容很少，简单表述一下我现所学的数组主要就是将不同类型的数据存入到一起，而在上一小节中的map集合就用到了这么一个做法，照添加键值对的方式一： += （”a“ ，1）其实就是一种元组的形式，只不过在键值对中运用了语法将其进行转换，转变为键值对形式塞入了map集合中而已。

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

今天所学的就是了解了一下scala中集合的种类，以及这些类型之间的关系，不可变与可变之间的差异；通过学习就会了解到，在scala中很喜欢使用极简化来表示某些功能，但是scala不会抹去正常该有的append亦或prepend等英文的功能方式，相比java有了更多选择，但缺点就是选择太多了，容易记忆疲劳，相对应的我个人认为能省及省吧，符号类用多了才能体现scala的优势。

日期：10月24日 scala集合常用函数、队列Queue、并行集合、模式匹配

尚硅谷大数据技术之Scala入门到精通教程（小白快速上手scala）哔哩哔哩bilibili

1.今天所学内容摘要：

Scala中集合常用函数讲述的其实就是一些集合所拥有方法的调用，几乎能想到的内容都有对应的方法实现，主要包括基础的方法，计算求和、求乘、排序的简单函数方法，过滤、映射、扁平化等高级计算函数方法，具体的实现都可以查阅，了解有这些东西存在即可；然后就是队列，队列就是一种先进先出的数据存储形式，了解即可；并行集合的存在其实就是多线程的意思，并非多个集合的意思，而是通过par方法实现的多线程执行任务的方式。

1.1.模式匹配

模式匹配其实就是java中的switch内容，只不过scala中用match表述，且功能更加强大；模式匹配可以对应的内容不只是常量这么简单，如通过变量接收，接收类型，接收对象，都是可以实现的。

1.1.1.模式守卫

模式守卫类似于之前学习的for循环中的守卫，就是在模式匹配中加入条件判断，判断一个范围内是否满足条件；其实就是加入了if判断语句。

    val name = StdIn.readLine("请输入：")
    val 答案 = name match {
      case "黄超群" => "大帅被"    //形式1
      case sym if sym == "孙燕敏" => "大数据之光"   //形式2
      case _  => "大春被"
    }
    println(答案)

1.1.2. 匹配常量

模式匹配可以匹配所有的字面量，包括字符串，字符，数字，布尔值等等。

object TestMatchVal {
    def main(args: Array[String]): Unit = {
        println(describe(6))
    }
    def describe(x: Any) = x match {
        case 10 => "Int five" 
        case "hello" => "String hello"
        case true => "Boolean true"
        case '+' => "Char +"
    }
}

1.1.3.匹配类型

类型匹配是指可以匹配如Int、String、Char等数据的类型

val typeSidin = StdIn.readLine("请输入：")
def ty(x: Any): String = x match {
  case i: Int => "Int: " + i
  case s: String => "String: " + s
  case _ => "无知"
}
println(ty(typeSidin))

1.1.4. 匹配数组/列表/元组

这是指可以对集合进行精确的匹配，例如匹配只有两个元素的、且第一个元素为 0 的数组。在模式匹配中对于这部分内容的匹配操作其实都是类似的没有太大差距的

val arr = Array(0,1,2)
val result = arr match {
  case Array(0) => "0"
  case Array(x,y) => "包含两个数据"
  case Array(0, _*) => "以0开头的数组"
  case _ => "not"
}
println(result)

1.1.5.匹配对象及样例类

在匹配对象的时候，要注意我们不能直接通过class来new一个对象进行匹配，而是需要通过伴生对象中的unapply方法实现，而unapply方法的作业其实就是将传入对象的内容提取出来，用于判断而已；当然也可以同在class类前加case将类转变为样例类实现之前的功能，这个操作的意义就是样例类自动生成了伴生对象，并且伴生对象中自动提供了一些常用的方法，如 apply、unapply、toString、equals、hashCode 和 copy等。

case class User(name: String, age: Int)
object TestMatchUnapply {
    def main(args: Array[String]): Unit = {
        val user: User = User("zhangsan", 11)
        val result = user match {
            case User("zhangsan", 11) => "yes"
            case _ => "no"
        }
        println(result)
    }
}

1.1.6.偏函数中的模式匹配(了解)

我个人觉得偏函数就是省略了match的简化模式匹配写法

val Abs1: PartialFunction[Int,Int] = {
  case x if x > 0 => x
}
val Abs2: PartialFunction[Int,Int] = {
  case x if x < 0 => -x
}
def abs(n: Int): Int = (Abs1 orElse Abs2)(n)

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

今天最主要的学习内容就是模式匹配，相对于其他内容的方法调用，这部分内容更加灵活；模式匹配的根本就是对match的运用，无论是匹配常量还是类型、对象，只有在对应的场景中才会运用到，在Scala中其实很多的内容如绝对值的判断等都是可以通过模式匹配自己编写的，又或者对象的创建等，个人感觉今天学习的内容相对而言还是很重要的，在大数据的使用中应该会常出现。

日期：10月25日前端基础之HTML篇

01-前端基础导学课程哔哩哔哩bilibili

1.今天所学内容摘要：

今天复习了前端基础的HTML部分内容，因为基本大部分都学习过了所以笔记中不会过多讲述；今天学习内容可以划分为：加粗等的特效标签、排版用的表单，表格，列表等标签、音视频标签、常用的图像与超链接标签等标签；对于这些内容只有音视频标签是以前没学习过的，其他内容都是已经了解过的知识点。

1.1.音频标签

controls : 显示音频播放面板 loop : 循环播放 autoplay : 自动播放

<audio src="./music/SWIN-S/SWIN-S - 只因你太美.flac" controls></audio>

1.2.视频标签

controls : 显示音频播放面板 loop : 循环播放 muted : 静音播放 autoplay : 自动播放

<video src="./video/蔡徐坤.mp4" controls></video>

注意：html是有一个新特性的，就是当参数与属性名一样的时候，参数是可以不写的，单写一个属性名就可以实现作用了

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

对于HTML的内容，本来是不用再看了的，但是因为自己好多都记得不太清楚了，所以还是选择粗略的都看一遍，对于学习过的内容进行复习，对于以前没学习到的内容进行学习；个人感觉这样子的过一遍也不是没有用，至少让自己的底盘稳一点，不至于之后出现什么HTML部分的毛病，明天开始就将学习css中的内容了。

日期：10月26日前端基础之CSS篇

01-前端基础导学课程哔哩哔哩bilibili

1.今天所学内容摘要：

今日所学内容主要涉及CSS样式；包括CSS使用的三种形式，以及CSS中字体或文本样式的使用，再则就是CSS中标签、类、id、全局样式的定义形式等，最后也是了解了CSS中对于背景的一些设定等；这一部分基础内容都是简单的，没有什么问题的，因此这一部分内容也就是简单的过了一边。

1.1.转换显示模式（常用）

转换显示模式就是在三种显示模式（块级、行内块，行内）之间进行切换，例如div标签创建的元素就是一个块级，行内块就是指在一行内显示的块形元素，行内则是无块形元素。

/* 
转换显示模式
block : 块级
inline-block ： 行内块
inline ： 行内 */
display: block;

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

今天学习下来没有什么问题出现，学习到的一个常用的重点内容应该就只有一个显示模式转换的属性；总体来说其实对于CSS基础的学习也算是复习，是由基础在的，然后这一部分内容又是最最基础的底部内容，所以学习起来才不难，然后笔记中也是没有去写太多的基础内容，实在没必要都能在菜鸟中搜到，除了重要常用内容记一笔以外。

日期：10月30日 CSS浮动与 FLEX布局

01-前端基础导学课程哔哩哔哩bilibili

1.今天所学内容摘要：

今天所学内容中主要就是浮动和FlEX两种布局的使用；其中浮动的使用在实际案例中较少，因为浮动会出现叠加的负面效果，相对FLEX来讲不可控性较大；而FLEX布局的可控性强，不会出现内容叠加等情况，再则FLEX布局相对于浮动而言更加智能简便，浮动只能让块不被固定，而FLEX能直接实现块级的各种布局。

1.1. 双伪元素法

before:解决外边距塌陷问题

双伪元素法是浮动中的一种用法；主要作用就是解决浮动所带来的塌陷、叠加等影响，只需要了解即可了

.clearfix::before,
.clearfix::after {
    content: "";
    display: table;
}
.clearfix::after {
    clear: both;
}

1.2.FLEX布局

FLEX布局的使用非常灵活，主要依赖主轴与侧轴来进行排版。且在布局中主侧之间是可以转换的；FLEX能直接实现的布局效果也会有多种，FLEX的使用不会出现类似浮动那样的bug，而是更加实用一点。

/* Flex弹性布局 */
display: flex;
/* 类似左对齐 */
justify-content: flex-start;
/* 类似居中 */
justify-content: center;
/* 水平排列 */
justify-content: space-between; 

/* 垂直居中 */
align-items: center;
/* 顶部 */
align-items: flex-start; 

/* 修改主轴方向
   垂直排列 */
flex-direction: column;

/* 换行显示 */
flex-wrap: wrap;

/* 行对齐，行之间的距离 */
align-content: space-around;

/*使当前块垂直方向底部对齐*/
align-self: flex-end;
/*当前块占总块内容比例*/
flex: 1;

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

今天学习的速度还行，除了浮动与FLEX两块内容外，主要还是一个网页的设计案例；暂时也只是学习了网页导航处的设计，在设计中就会发现，视频中老师讲的时候总会提到一个大局观，要考虑当前网页中，所有元素都会用到的样式，进行封装伪一个CSS样式文件，之间引入，其次在导航条部分设计时，要有一个从外到内，划分式布局的思路；对于某些内容，实现的方式有很多种，不同人的思考方式不同，不够能用背景解决的事情，尽量不要单设一个div块级元素

日期：10月31日网页设计：学成在线案例、元素定位

01-前端基础导学课程哔哩哔哩bilibili

1.今天所学内容摘要：

对于学成在线的网页设计案例：我个人觉得其实网页的设计主要是依赖于CSS的样式分配；在练习这个案例的时候，需要提前进行大体的区域规划；就这个案例而言划分为：头部区域、中心区域、正文区域；其中头部其实就是通栏，中心就是图片播放区，正文就是产品介绍。另外今天也是了解了一下元素在网页中如何实现定位效果

1.1.元素定位

元素定位其实就是网页中内容实现具体位置摆放的功能；主要有相对、绝对、固定定位等；其中绝对与相对往往配合使用：子绝父相的原理；再则固定定位的作用如控制当前网页导航条固定，不会因为网页划动而消失，固定于顶部。

1.1.1.相对定位

相对定位以自身原位置为准，在此基础上移动，且会独占一行，一般不在网页中直接使用

/* 相对定位 */
position: relative;
top: 10px;
left: 10px;

1.1.2.绝对定位

绝对定位一般配合父级的相对定位使用，用于达到子元素在父元素中定位摆放的作用

/* 绝对定位 */
position: absolute;
top: 50%;
left: 50%;

1.1.3.固定定位

固定定位就是将元素固定在具体的位置，元素不会随网页移动而移动

/* 固定定位 */
position: fixed;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);

注意：transform的作用就是将元素移动的中心点调到中央位置

2.所遇到的问题描述：

3.扩展学习部分：

4.学习总结：

今天学习的内容总体来说是之前学习小内容的综合应用，其中最为常用的当属FLEX布局效果以及display的块级转换功能；FLEX布局是贯穿整个网页设计的，display的块级作用则是让行内的改为块级，使得我可以为元素添加宽高等元素；再则网页的设计片离不开，基础的网页排版需要提前设计，然后通过软件提取位置信息，最后进行代码编辑设计网页，在位置的排版里最常用的是内外边距的设定。

没有CD的男人

关注

42
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
微信小程序+scala+linux内容笔记解析

1.组件的生命周期1.1.lifetimes节点在小程序组件中，生命周期函数可以直接定义在 Component 构造器的第一级参数中，可以在 lifetimes 字段内进行声明(这是推荐的方式，其优先级最高)。attached() { //组件实例进入页面节点树时执行},},},1.2.pageLifetimes节点show: function(){ console.log('show') }, //页面被展示。
复制链接

扫一扫