# 前提
> django默认不支持websocket，需要安装组件：
```shell
pip install channels daphne
```
- 在较新版本的Django框架下还需要安装daphne



# 配置
## 注册channels 
```Python
INSTALLED_APPS = [
    "daphne",
    "channels",
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "web.apps.WebConfig"
]
```

![image.png](/static/img/936735bef6c1249ca0eaac7ac0fd9112.image.webp)

## 在settings.py中添加 asgi_application
```Python
ASGI_APPLICATION = "ws_demo.asgi.application"
```
![](https://www.gycblog.cn/static/img/c32ee4bb2d72526ee00ed11a8c7b6eb6.image.webp)

## 修改asgi.py文件
```Python
import os
from django.core.asgi import get_asgi_application
from channels.routing import ProtocolTypeRouter, URLRouter

from . import routing

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'ws_demo.settings')

# application = get_asgi_application()

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": URLRouter(routing.websocket_urlpatterns),
})
```

## 在settings.py的同级目录创建 routing.py 
```Python
from django.urls import re_path

from app01 import consumers

websocket_urlpatterns = [
    re_path(r'ws/(?P<group>\w+)/$', consumers.ChatConsumer.as_asgi()),
]
```

## 在app目录下创建 consumers.py，编写处理处理websocket的业务逻辑。
```Python
from channels.generic.websocket import WebsocketConsumer
from channels.exceptions import StopConsumer


class ChatConsumer(WebsocketConsumer):
    def websocket_connect(self, message):
        # 有客户端来向后端发送websocket连接的请求时，自动触发。
        # 服务端允许和客户端创建连接。
        self.accept()

    def websocket_receive(self, message):
        # 浏览器基于websocket向后端发送数据，自动触发接收消息。
        print(message)
        self.send("不要回复不要回复")
        # self.close()

    def websocket_disconnect(self, message):
        # 客户端与服务端断开连接时，自动触发。
        print("断开连接")
        raise StopConsumer()
```

## 启动效果

- **传统启动:**

![image-20210627142144020.png](/static/img/751754f98b1ed4d528c8dcfbd258c5ea.image-20210627142144020.webp)

- **实现了WebSocket启动:**

![image.png](/static/img/f73ffdf3142464aa70108b602b1358ce.image.webp)

## 学习视频
<iframe src="//player.bilibili.com/player.html?aid=979090858&bvid=BV1J44y1p7NX&cid=510022749&p=1&autoplay=0&high_quality=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true" style="width:100%;aspect-ratio:16/10;"> </iframe>

Django 实现websocket

# 基于 GitPython 的 Git 仓库管理封装

在日常开发中，操作 Git 仓库是一项频繁且重要的任务。为了简化 Git 的操作流程，使用 Python 编写一些自动化脚本是非常实用的选择。本文将介绍如何通过 GitPython 库封装常见的 Git 操作，例如：拉取代码、获取分支、提交记录、标签以及切换分支和提交。

## 前置条件

在开始之前，请确保已经安装了 `GitPython` 库。你可以通过以下命令进行安装：

```bash
pip install gitpython
```

## Git 仓库封装类

我们定义了一个名为 `GitRepository` 的类，封装了对 Git 仓库的常用操作。类的核心功能包括：克隆远程仓库、拉取代码、获取分支、获取提交记录、标签管理，以及在不同分支、提交和标签之间进行切换。



### 代码结构

首先来看这个类的结构和主要方法：

```python
import os
from git.repo import Repo
from git.repo.fun import is_git_dir

class GitRepository(object):
    """
    git仓库管理类，提供初始化、代码拉取、分支、提交记录、标签管理等功能
    """

    def __init__(self, local_path, repo_url, branch='master'):
        self.local_path = local_path
        self.repo_url = repo_url
        self.repo = None
        self.initial(repo_url, branch)

    def initial(self, repo_url, branch):
        """
        初始化git仓库，如果本地不存在则从远程克隆，否则打开已有仓库
        """
        if not os.path.exists(self.local_path):
            os.makedirs(self.local_path)

        git_local_path = os.path.join(self.local_path, '.git')
        if not is_git_dir(git_local_path):
            # 从远程克隆仓库
            self.repo = Repo.clone_from(repo_url, to_path=self.local_path, branch=branch)
        else:
            # 使用已有仓库
            self.repo = Repo(self.local_path)

    def pull(self):
        """
        拉取最新代码
        """
        self.repo.git.pull()

    def branches(self):
        """
        获取所有远程分支
        """
        branches = self.repo.remote().refs
        return [item.remote_head for item in branches if item.remote_head not in ['HEAD', ]]

    def commits(self):
        """
        获取最近的提交记录
        """
        commit_log = self.repo.git.log('--pretty={"commit":"%h","author":"%an","summary":"%s","date":"%cd"}',
                                       max_count=50,
                                       date='format:%Y-%m-%d %H:%M')
        log_list = commit_log.split("\n")
        return [eval(item) for item in log_list]

    def tags(self):
        """
        获取所有tag
        """
        return [tag.name for tag in self.repo.tags]

    def change_to_branch(self, branch):
        """
        切换分支
        """
        self.repo.git.checkout(branch)

    def change_to_commit(self, branch, commit):
        """
        切换到指定commit
        """
        self.change_to_branch(branch=branch)
        self.repo.git.reset('--hard', commit)

    def change_to_tag(self, tag):
        """
        切换到指定tag
        """
        self.repo.git.checkout(tag)
```

### 详细说明

#### 1. 初始化 Git 仓库

在 `GitRepository` 的 `__init__` 方法中，我们传入了仓库的本地路径 `local_path`、远程仓库地址 `repo_url`，以及可选的分支名 `branch`。`initial` 方法首先检查本地路径是否存在 `.git` 文件夹，若不存在，则通过 `clone_from` 方法从远程克隆仓库到本地。如果本地已经存在仓库，则直接打开。

#### 2. 拉取最新代码

`pull` 方法使用 GitPython 提供的 `git.pull()` 功能从远程仓库拉取最新的代码。此方法等同于我们在命令行执行的 `git pull`。

#### 3. 获取分支

`branches` 方法通过 `remote().refs` 获取所有的远程分支。我们过滤掉了 `HEAD`，并返回了分支名称列表。

#### 4. 提交记录

在 `commits` 方法中，我们使用了 Git 的日志命令，指定了输出格式为 JSON，并提取了最近 50 条提交记录。返回结果是一个包含每次提交的 `commit` 哈希值、作者、提交摘要和提交日期的列表。

#### 5. 标签管理

`tags` 方法简单地返回了仓库中的所有标签（tag）列表，使用 `self.repo.tags` 进行获取。

#### 6. 切换分支、commit 和标签

类中还提供了 `change_to_branch`、`change_to_commit` 和 `change_to_tag` 三个方法，分别实现了分支、提交哈希和标签的切换操作。我们利用 `git.checkout` 和 `git.reset` 来实现这些功能。

## 使用示例

以下是如何使用这个 `GitRepository` 类的一个示例：

```python
if __name__ == '__main__':
    local_path = os.path.join('codes', 'myproject')
    repo = GitRepository(local_path, 'https://github.com/your-repo.git')

    # 获取远程分支
    branch_list = repo.branches()
    print("远程分支:", branch_list)

    # 切换到 dev 分支并拉取代码
    repo.change_to_branch('dev')
    repo.pull()

    # 获取最近 50 条提交记录
    commit_list = repo.commits()
    print("最近提交记录:", commit_list)

    # 获取所有标签
    tags = repo.tags()
    print("仓库标签:", tags)
```

## 总结

通过封装 GitPython，我们能够更加高效地管理 Git 仓库。此类提供了初始化、代码拉取、获取分支和提交记录、切换分支和标签等功能，可以方便地集成到自动化脚本或 CI/CD 流程中。希望本文能帮助你更好地理解和使用 GitPython 库。


## 我的示例
```Python
import os
from git.repo import Repo
from git.repo.fun import is_git_dir


class GitRepository(object):
    """
    git仓库管理
    """

    def __init__(self, local_path, repo_url, branch='master'):
        self.local_path = local_path
        self.repo_url = repo_url
        self.repo = None
        self.initial(repo_url, branch)

    def initial(self, repo_url, branch):
        """
        初始化git仓库
        :param repo_url:
        :param branch:
        :return:
        """
        if not os.path.exists(self.local_path):
            os.makedirs(self.local_path)

        git_local_path = os.path.join(self.local_path, '.git')
        if not is_git_dir(git_local_path):
            self.repo = Repo.clone_from(repo_url, to_path=self.local_path, branch=branch)
        else:
            self.repo = Repo(self.local_path)

    def pull(self):
        """
        从线上拉最新代码
        :return:
        """
        self.repo.git.pull()

    def branches(self):
        """
        获取所有分支
        :return:
        """
        branches = self.repo.remote().refs
        return [item.remote_head for item in branches if item.remote_head not in ['HEAD', ]]

    def commits(self):
        """
        获取所有提交记录
        :return:
        """
        commit_log = self.repo.git.log('--pretty={"commit":"%h","author":"%an","summary":"%s","date":"%cd"}',
                                       max_count=50,
                                       date='format:%Y-%m-%d %H:%M')
        log_list = commit_log.split("\n")
        return [eval(item) for item in log_list]

    def tags(self):
        """
        获取所有tag
        :return:
        """
        return [tag.name for tag in self.repo.tags]

    def change_to_branch(self, branch):
        """
        切换分值
        :param branch:
        :return:
        """
        self.repo.git.checkout(branch)

    def change_to_commit(self, branch, commit):
        """
        切换commit
        :param branch:
        :param commit:
        :return:
        """
        self.change_to_branch(branch=branch)
        self.repo.git.reset('--hard', commit)

    def change_to_tag(self, tag):
        """
        切换tag
        :param tag:
        :return:
        """
        self.repo.git.checkout(tag)


if __name__ == '__main__':
    local_path = os.path.join('codes', 'luffycity')
    repo = GitRepository(local_path, 'https://gitee.com/wupeiqi/fuck.git')
    branch_list = repo.branches()
    print(branch_list)
    repo.change_to_branch('dev')
    repo.pull()
```

基于 GitPython 的 Git 仓库管理封装

#### 背景
在远程服务器的日常操作中，常常需要进行文件传输、命令执行等操作。使用手动SSH登录然后执行命令显然不够高效，特别是在需要自动化执行任务时。Python 的 `paramiko` 库提供了强大的 SSH 客户端功能，能够帮助开发者简化 SSH 连接和文件操作的实现。本文将介绍如何通过封装 `paramiko` 库，创建一个便于管理和操作的 `SSHProxy` 类，并通过面向对象的上下文管理方式优化代码结构。

#### 1. Paramiko简介
`paramiko` 是一个用于 SSH 连接和 SFTP 文件传输的 Python 库。通过这个库，你可以在 Python 程序中建立 SSH 连接、远程执行命令、传输文件等。

核心功能：
- 通过密码或密钥进行身份验证的 SSH 连接。
- 通过 `exec_command` 远程执行命令。
- 通过 SFTP 传输文件。



#### 2. SSHProxy类封装
我们通过封装 `paramiko` 的 `Transport` 和 `SSHClient`，实现了一个简单的 `SSHProxy` 类，能够简化 SSH 的连接、命令执行和文件上传。下面是代码的详细实现。

##### 密码认证的 SSHProxy 实现

```python
import paramiko

class SSHProxy(object):
    def __init__(self, hostname, port, username, password):
        self.hostname = hostname
        self.port = port
        self.username = username
        self.password = password
        self.transport = None

    def open(self):
        """ 打开SSH连接 """
        self.transport = paramiko.Transport((self.hostname, self.port))
        self.transport.connect(username=self.username, password=self.password)

    def command(self, cmd):
        """ 远程执行命令 """
        ssh = paramiko.SSHClient()
        ssh._transport = self.transport
        stdin, stdout, stderr = ssh.exec_command(cmd)
        result = stdout.read()
        return result

    def upload(self, local_path, remote_path):
        """ 上传文件 """
        sftp = paramiko.SFTPClient.from_transport(self.transport)
        sftp.put(local_path, remote_path)
        sftp.close()

    def close(self):
        """ 关闭SSH连接 """
        self.transport.close()

    def __enter__(self):
        """ 上下文管理协议：进入 """
        self.open()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        """ 上下文管理协议：退出 """
        self.close()

if __name__ == '__main__':
    with SSHProxy("123.206.16.61", 22, 'root', 'password') as ssh:
        ssh.command('df')
        ssh.upload(r'D:\path\file.txt', '/data/file.txt')
```

#### 3. 基于密钥的认证实现
在某些场景下，基于密码的认证不够安全或方便，因此我们可以通过 SSH 密钥认证来连接远程服务器。以下是使用密钥认证的 `SSHProxy` 实现：

```python
class SSHProxy(object):
    def __init__(self, hostname, port, username, private_key_path):
        self.hostname = hostname
        self.port = port
        self.username = username
        self.private_key_path = private_key_path
        self.transport = None

    def open(self):
        """ 使用RSA密钥打开SSH连接 """
        private_key = paramiko.RSAKey.from_private_key_file(self.private_key_path)
        self.transport = paramiko.Transport((self.hostname, self.port))
        self.transport.connect(username=self.username, pkey=private_key)

    def close(self):
        """ 关闭SSH连接 """
        self.transport.close()

    def command(self, cmd):
        """ 远程执行命令 """
        ssh = paramiko.SSHClient()
        ssh._transport = self.transport
        stdin, stdout, stderr = ssh.exec_command(cmd)
        result = stdout.read()
        return result

    def upload(self, local_path, remote_path):
        """ 上传文件 """
        sftp = paramiko.SFTPClient.from_transport(self.transport)
        sftp.put(local_path, remote_path)
        sftp.close()

    def __enter__(self):
        """ 上下文管理协议：进入 """
        self.open()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        """ 上下文管理协议：退出 """
        self.close()
```

#### 4. 面向对象的上下文管理协议
在上述代码中，`__enter__` 和 `__exit__` 方法实现了上下文管理协议。通过这种方式，我们可以使用 `with` 语句简化资源管理。

上下文管理协议是 Python 面向对象中的一种特殊协议，允许对象控制 `with` 语句的行为。当进入 `with` 语句时，会自动调用 `__enter__` 方法；而当退出时，无论是否抛出异常，都会调用 `__exit__` 方法来确保资源释放。通过这种机制，我们可以避免忘记关闭资源。

一个简单的上下文管理类实现如下：

```python
class Context:
    def __enter__(self):
        print('进入上下文')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('退出上下文')

    def do_something(self):
        print('执行操作')

# 使用上下文管理
with Context() as ctx:
    ctx.do_something()
```

#### 5. 总结
通过封装 `paramiko`，我们能够更加高效地管理 SSH 连接，简化了命令执行和文件上传的流程。此外，使用上下文管理协议可以确保资源在使用完毕后正确释放，从而避免内存泄漏或连接未关闭的问题。

这类封装适合于日常自动化任务的执行，比如定期备份、远程日志收集等。通过在代码中合理应用上下文管理协议和封装设计，可以使代码更加简洁和易维护。

## 我的示例
```Python
import paramiko


class SSHProxy(object):

    def __init__(self, hostname, port, username, private_key_path):
        self.hostname = hostname
        self.port = port
        self.username = username
        self.private_key_path = private_key_path

        self.transport = None

    def open(self):
        private_key = paramiko.RSAKey.from_private_key_file(self.private_key_path)
        self.transport = paramiko.Transport((self.hostname, self.port))
        self.transport.connect(username=self.username, pkey=private_key)

    def close(self):
        self.transport.close()

    def command(self, cmd):
        ssh = paramiko.SSHClient()
        ssh._transport = self.transport
        stdin, stdout, stderr = ssh.exec_command(cmd)
        result = stdout.read()
        # ssh.close()
        return result

    def upload(self, local_path, remote_path):
        sftp = paramiko.SFTPClient.from_transport(self.transport)
        sftp.put(local_path, remote_path)
        sftp.close()

    def __enter__(self):
        self.open()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()


if __name__ == '__main__':
    with SSHProxy('10.211.55.25', 22, 'root', '/Users/wupeiqi/.ssh/id_rsa') as ssh:
        # v1 = ssh.command('sudo ifconfig')
        # print(v1)
        ssh.upload('your.tar', '/data/your.tar')
```

Paramiko库中的SSH代理封装实现

Linux练习小结_05

## 什么是Shell脚本
### 示例
看个例子吧：

	#!/bin/sh
	cd ~
	mkdir shell_tut
	cd shell_tut
	
	for ((i=0; i<10; i++)); do
		touch test_$i.txt
	done

### 示例解释

- 第1行：指定脚本解释器，这里是用/bin/sh做解释器的
- 第2行：切换到当前用户的home目录
- 第3行：创建一个目录shell_tut
- 第4行：切换到shell_tut目录
- 第5行：循环条件，一共循环10次
- 第6行：创建一个test_0…9.txt文件
- 第7行：循环体结束

mkdir, touch都是系统自带的程序，一般在/bin或者/usr/bin目录下。for, do, done是sh脚本语言的关键字。



### shell和shell脚本的概念
shell是指一种应用程序，这个应用程序提供了一个界面，用户通过这个界面访问操作系统内核的服务。Ken Thompson的sh是第一种Unix Shell，Windows Explorer是一个典型的图形界面Shell。

shell脚本（shell script），是一种为shell编写的脚本程序。业界所说的shell通常都是指shell脚本，但读者朋友要知道，shell和shell script是两个不同的概念。由于习惯的原因，简洁起见，本文出现的“shell编程”都是指shell脚本编程，不是指开发shell自身（如Windows Explorer扩展开发）。



## 环境
shell编程跟java、php编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。

### OS
当前主流的操作系统都支持shell编程，本文档所述的shell编程是指Linux下的shell，讲的基本都是POSIX标准下的功能，所以，也适用于Unix及BSD（如Mac OS）。

#### Linux
Linux默认安装就带了shell解释器。

#### Mac OS
Mac OS不仅带了sh、bash这两个最基础的解释器，还内置了ksh、csh、zsh等不常用的解释器。

#### Windows上的模拟器
windows出厂时没有内置shell解释器，需要自行安装，为了同时能用grep, awk, curl等工具，最好装一个cygwin或者mingw来模拟linux环境。

- [cygwin](http://www.cygwin.com)
- [mingw](http://www.mingw.org)

### 脚本解释器
#### sh
即Bourne shell，POSIX（Portable Operating System Interface）标准的shell解释器，它的二进制文件路径通常是/bin/sh，由Bell Labs开发。

本文讲的是sh，如果你使用其它语言用作shell编程，请自行参考相应语言的文档。

#### bash
Bash是Bourne shell的替代品，属GNU Project，二进制文件路径通常是/bin/bash。业界通常混用bash、sh、和shell，比如你会经常在招聘运维工程师的文案中见到：熟悉Linux Bash编程，精通Shell编程。

在CentOS里，/bin/sh是一个指向/bin/bash的符号链接:

	[root@centosraw ~]# ls -l /bin/*sh
	-rwxr-xr-x. 1 root root 903272 Feb 22 05:09 /bin/bash
	-rwxr-xr-x. 1 root root 106216 Oct 17  2012 /bin/dash
	lrwxrwxrwx. 1 root root      4 Mar 22 10:22 /bin/sh -> bash

但在Mac OS上不是，/bin/sh和/bin/bash是两个不同的文件，尽管它们的大小只相差100字节左右:

	iMac:~ wuxiao$ ls -l /bin/*sh
	-r-xr-xr-x  1 root  wheel  1371648  6 Nov 16:52 /bin/bash
	-rwxr-xr-x  2 root  wheel   772992  6 Nov 16:52 /bin/csh
	-r-xr-xr-x  1 root  wheel  2180736  6 Nov 16:52 /bin/ksh
	-r-xr-xr-x  1 root  wheel  1371712  6 Nov 16:52 /bin/sh
	-rwxr-xr-x  2 root  wheel   772992  6 Nov 16:52 /bin/tcsh
	-rwxr-xr-x  1 root  wheel  1103984  6 Nov 16:52 /bin/zsh

#### 高级编程语言
理论上讲，只要一门语言提供了解释器（而不仅是编译器），这门语言就可以胜任脚本编程，常见的解释型语言都是可以用作脚本编程的，如：Perl、Tcl、Python、PHP、Ruby。Perl是最老牌的脚本编程语言了，Python这些年也成了一些linux发行版的预置解释器。

编译型语言，只要有解释器，也可以用作脚本编程，如C shell是内置的（/bin/csh），Java有第三方解释器Jshell，Ada有收费的解释器AdaScript。

如下是一个PHP Shell Script示例（假设文件名叫test.php）：

	#!/usr/bin/php
	<?php
	for ($i=0; $i < 10; $i++)
	        echo $i . "\n";

执行：

	/usr/bin/php test.php
或者：

	chmod +x test.php
	./test.php

## 如何选择shell编程语言
### 熟悉 vs 陌生
如果你已经掌握了一门编程语言（如PHP、Python、Java、JavaScript），建议你就直接使用这门语言编写脚本程序，虽然某些地方会有点啰嗦，但你能利用在这门语言领域里的经验（单元测试、单步调试、IDE、第三方类库）。

新增的学习成本很小，只要学会怎么使用shell解释器（Jshell、AdaScript）就可以了。


### 简单 vs 高级
如果你觉得自己熟悉的语言（如Java、C）写shell脚本实在太啰嗦，你只是想做一些备份文件、安装软件、下载数据之类的事情，学着使用sh，bash会是一个好主意。

shell只定义了一个非常简单的编程语言，所以，如果你的脚本程序复杂度较高，或者要操作的数据结构比较复杂，那么还是应该使用Python、Perl这样的脚本语言，或者是你本来就已经很擅长的高级语言。因为sh和bash在这方面很弱，比如说：

- 它的函数只能返回字串，无法返回数组
- 它不支持面向对象，你无法实现一些优雅的设计模式
- 它是解释型的，一边解释一边执行，连PHP那种预编译都不是，如果你的脚本包含错误(例如调用了不存在的函数)，只要没执行到这一行，就不会报错

### 环境兼容性
如果你的脚本是提供给别的用户使用，使用sh或者bash，你的脚本将具有最好的环境兼容性，perl很早就是linux标配了，python这些年也成了一些linux发行版的标配，至于mac os，它默认安装了perl、python、ruby、php、java等主流编程语言。


## 第一个shell脚本
### 编写
打开文本编辑器，新建一个文件，扩展名为sh（sh代表shell），扩展名并不影响脚本执行，见名知意就好，如果你用php写shell 脚本，扩展名就用php好了。

输入一些代码，第一行一般是这样：

	#!/bin/bash
	#!/usr/bin/php

“#!”是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行。

### 运行
运行Shell脚本有两种方法：
#### 作为可执行程序

	chmod +x test.sh
	./test.sh

注意，一定要写成./test.sh，而不是test.sh，运行其它二进制的程序也一样，直接写test.sh，linux系统会去PATH里寻找有没有叫test.sh的，而只有/bin, /sbin, /usr/bin，/usr/sbin等在PATH里，你的当前目录通常不在PATH里，所以写成test.sh是会找不到命令的，要用./test.sh告诉系统说，就在当前目录找。

通过这种方式运行bash脚本，第一行一定要写对，好让系统查找到正确的解释器。

这里的"系统"，其实就是shell这个应用程序（想象一下Windows Explorer），但我故意写成系统，是方便理解，既然这个系统就是指shell，那么一个使用/bin/sh作为解释器的脚本是不是可以省去第一行呢？是的。

#### 作为解释器参数
这种运行方式是，直接运行解释器，其参数就是shell脚本的文件名，如：

	/bin/sh test.sh
	/bin/php test.php

这种方式运行的脚本，不需要在第一行指定解释器信息，写了也没用。

## 变量
### 定义变量
定义变量时，变量名不加美元符号（$），如：

	your_name="qinjx"

注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。

除了显式地直接赋值，还可以用语句给变量赋值，如：

	for file in `ls /etc`

### 使用变量
使用一个定义过的变量，只要在变量名前面加美元符号即可，如：

	your_name="qinjx"
	echo $your_name
	echo ${your_name}

变量名外面的花括号是可选的，加不加都行，加花括号是为了帮助解释器识别变量的边界，比如下面这种情况：

	for skill in Ada Coffe Action Java; do
		echo "I am good at ${skill}Script"
	done

如果不给skill变量加花括号，写成echo "I am good at $skillScript"，解释器就会把$skillScript当成一个变量（其值为空），代码执行结果就不是我们期望的样子了。

推荐给所有变量加上花括号，这是个好的编程习惯。IntelliJ IDEA编写shell script时，IDE就会提示加花括号。

### 重定义变量
已定义的变量，可以被重新定义，如：

	your_name="qinjx"
	echo $your_name
	
	your_name="alibaba"
	echo $your_name
	
这样写是合法的，但注意，第二次赋值的时候不能写$your_name="alibaba"，使用变量的时候才加美元符。

## 注释
以“#”开头的行就是注释，会被解释器忽略。

### 多行注释
sh里没有多行注释，只能每一行加一个#号。就像这样：

	#--------------------------------------------
	# 这是一个自动打ipa的脚本，基于webfrogs的ipa-build书写：https://github.com/webfrogs/xcode_shell/blob/master/ipa-build
	
	# 功能：自动为etao ios app打包，产出物为14个渠道的ipa包
	# 特色：全自动打包，不需要输入任何参数
	#--------------------------------------------
	
	##### 用户配置区 开始 #####
	#
	#
	# 项目根目录，推荐将此脚本放在项目的根目录，这里就不用改了
	# 应用名，确保和Xcode里Product下的target_name.app名字一致
	#
	##### 用户配置区 结束  #####

如果在开发过程中，遇到大段的代码需要临时注释起来，过一会儿又取消注释，怎么办呢？每一行加个#符号太费力了，可以把这一段要注释的代码用一对花括号括起来，定义成一个函数，没有地方调用这个函数，这块代码就不会执行，达到了和注释一样的效果。

## 字符串
字符串是shell编程中最常用最有用的数据类型（除了数字和字符串，也没啥其它类型好用了，哈哈），字符串可以用单引号，也可以用双引号，也可以不用引号。单双引号的区别跟PHP类似。

### 单引号

	str='this is a string'

单引号字符串的限制：

- 单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的
- 单引号字串中不能出现单引号（对单引号使用转义符后也不行）
 
### 双引号

	your_name='qinjx'
	str="Hello, I know your are \"$your_name\"! \n"

- 双引号里可以有变量
- 双引号里可以出现转义字符

### 字符串操作
#### 拼接字符串
	
	your_name="qinjx"
	greeting="hello, "$your_name" !"
	greeting_1="hello, ${your_name} !"
	
	echo $greeting $greeting_1

#### 获取字符串长度：

	string="abcd"
	echo ${#string} #输出：4

#### 提取子字符串

	string="alibaba is a great company"
	echo ${string:1:4} #输出：liba

#### 查找子字符串

	string="alibaba is a great company"
	echo `expr index "$string" is`#输出：3，这个语句的意思是：找出字母i在这名话中的位置，要在linux下运行，mac下会报错

#### 更多
参见本文档末尾的参考资料中[Advanced Bash-Scripting Guid Chapter 10.1](http://tldp.org/LDP/abs/html/string-manipulation.html)

## 数组

## 管道

## 条件判断

## 流程控制
和Java、PHP等语言不一样，sh的流程控制不可为空，如：

	<?php
	if (isset($_GET["q"])) {
		search(q);
	}
	else {
		//do nothing
	}

在sh/bash里可不能这么写，如果else分支没有语句执行，就不要写这个else。

还要注意，sh里的if [ $foo -eq 0 ]，这个方括号跟Java/PHP里if后面的圆括号大不相同，它是一个可执行程序（和ls, grep一样），想不到吧？在CentOS上，它在/usr/bin目录下：

	ll /usr/bin/[
	-rwxr-xr-x. 1 root root 33408 6月  22 2012 /usr/bin/[

正因为方括号在这里是一个可执行程序，方括号后面必须加空格，不能写成if [$foo -eq 0]

### if else
#### if

	if condition
	then
		command1 
		command2
		...
		commandN 
	fi

写成一行（适用于终端命令提示符）：

	if `ps -ef | grep ssh`;  then echo hello; fi
	
末尾的fi就是if倒过来拼写，后面还会遇到类似的

#### if else
	if condition
	then
		command1 
		command2
		...
		commandN
	else
		command
	fi

#### if else-if else

	if condition1
	then
		command1
	elif condition2
		command2
	else
		commandN
	fi

### for while
#### for
在开篇的示例里演示过了：

	for var in item1 item2 ... itemN
	do
		command1
		command2
		...
		commandN
	done

写成一行：

	for var in item1 item2 ... itemN; do command1; command2… done;

#### C风格的for

	for (( EXP1; EXP2; EXP3 ))
	do
		command1
		command2
		command3
	done

#### while
	while condition
	do
		command
	done
	
#### 无限循环

	while :
	do
		command
	done

或者

	while true
	do
		command
	done

或者

	for (( ; ; ))

#### until

	until condition
	do
		command
	done

### case

	case "${opt}" in
		"Install-Puppet-Server" )
			install_master $1
			exit
		;;

		"Install-Puppet-Client" )
			install_client $1
			exit
		;;

		"Config-Puppet-Server" )
			config_puppet_master
			exit
		;;

		"Config-Puppet-Client" )
			config_puppet_client
			exit
		;;

		"Exit" )
			exit
		;;

		* ) echo "Bad option, please choose again"
	esac

case的语法和C family语言差别很大，它需要一个esac（就是case反过来）作为结束标记，每个case分支用右圆括号，用两个分号表示break


## 函数
### 定义
### 调用

## 文件包含
可以使用source和.关键字，如：

	source ./function.sh
	. ./function.sh

在bash里，source和.是等效的，他们都是读入function.sh的内容并执行其内容（类似PHP里的include），为了更好的可移植性，推荐使用第二种写法。

包含一个文件和执行一个文件一样，也要写这个文件的路径，不能光写文件名，比如上述例子中:

	. ./function.sh

不可以写作：

	. function.sh

如果function.sh是用户传入的参数，如何获得它的绝对路径呢？方法是：

	real_path=`readlink -f $1`#$1是用户输入的参数，如function.sh
	. $real_path


## 用户输入
### 执行脚本时传入
### 脚本运行中输入
### select菜单

## stdin和stdout

## 常用的命令
sh脚本结合系统命令便有了强大的威力，在字符处理领域，有grep、awk、sed三剑客，grep负责找出特定的行，awk能将行拆分成多个字段，sed则可以实现更新插入删除等写操作。

### ps
查看进程列表

### grep
#### 排除grep自身
#### 查找与target相邻的结果

### awk

### sed
#### 插入
#### 替换
#### 删除

### xargs
### curl

## 综合案例


## 参考资料
- [Advanced Bash-Scripting Guide](http://tldp.org/LDP/abs/html/)，非常详细，非常易读，大量example，既可以当入门教材，也可以当做工具书查阅
- [Unix Shell Programming](http://www.tutorialspoint.com/unix/unix-shell.htm)
- [Linux Shell Scripting Tutorial - A Beginner's handbook](http://bash.cyberciti.biz/guide/Main_Page)