外贸独立站(日本)

分支里面的代码如果没有提交commit ，那么切换到其他分支下还是可以看
到(git status)这个分支下的代码.

但是如果我们现在想要切换到别的分支但是同时又不想提交commit我们的代码
该如何处理？

在你切换分支前，运行：git stash 就可以了
当你在其他分支改好了代码并切换回当前分支的时候，请git stash pop 

git stash
保存当前的工作进度。会分别对暂存区和工作区的状态进行保存

git stash save "message..."
这条命令实际上是第一条 git stash 命令的完整版

git stash list
显示进度列表。此命令显然暗示了git stash 可以多次保存工作进度，并用在恢复时候进行选择

git stash pop [--index] [<stash>]
如果不使用任何参数，会恢复最新保存的工作进度，
并将恢复的工作进度从存储的工作进度列表中清除。
如果提供参数（来自 git stash list 显示的列表），则从该 <stash> 中恢复。恢复完毕也将从进度列表中删除 <stash>。
选项--index 除了恢复工作区的文件外，还尝试恢复暂存区。

git stash apply [--index] [<stash>]
除了不删除恢复的进度之外，其余和 git stash pop 命令一样

git stash clear
删除所有存储的进度

一个高性能的支持丰富数据结构的 NoSQL 数据库, 用于替代 Redis.
基于google/leveldb 开发SSDB是一个开源的高性能数据库服务器, 
使用Google 的 LevelDB作为存储引擎, 大家有可能没听过leveldb的名字，
但是淘宝的开源nosql tair大家应该有所耳闻吧，他也是基于leveldb做的开发。
ssdb支持T级别的数据, 同时支持类似Redis中的zset和hash等数据结构,
在同时需求高性能和大数据的条件下, 是一个可以代替Redis的方案.
ssdb是一个持久化存储的KV系统，和Memcached、Redis这种内存型的KV系统不同，
ssdb不会像Redis一样狂吃内存，而是将大部分数据存储到磁盘上。

wget --no-check-certificate https://github.com/ideawu/ssdb/archive/master.zip
unzip master
cd ssdb-master
make
# optional, install ssdb in /usr/local/ssdb
sudo make install

# start master
./ssdb-server ssdb.conf

# or start as daemon
./ssdb-server -d ssdb.conf

<?php
require_once('SSDB.php');
$ssdb = new SimpleSSDB('127.0.0.1', 8888);
$resp = $ssdb->set('key', '123');
$resp = $ssdb->get('key');
echo $resp; // output: 123

LevelDB是google开源的一个key-value存储引擎库，类似于开源的Lucene索引库一样。
其他的软件开发者可以利用该库做二次开发，来满足定制需求。
LevelDB采用日志式的写方式来提高写性能，但是牺牲了部分读性能。
为了弥补牺牲了的读性能，一些人提议使用SSD作为存储介质。

修改ssdb.conf文件，把ip改成0.0.0.0，允许外网访问
高级应用可以查看主从这一块儿

CGI英文全程是 Command Gateway Interface，通常翻译为公共网关接口，
是HTTP服务器与机器上的其他程序进行通信的一个接口。
这个“其他程序”可以是使用任何计算机语言进行编 写，例如php，python，perl等等。
它通过CGI这个接口从HTTP服务器取得输入，然后把运行结果又通过CGI这个接口交给HTTP服务器， 而HTTP服务器把这个结果送给浏览器。

CGI 的出现让WEB从静态变为动态，随着web的越来越普及，很多的网站都需要有动态的页面，
以便与浏览者进行交互。CGI的缺点也越来越突出，因为HTTP 要生成一个动态页面，
系统就必须启动一个新的进程以运行CGI程序，
不断的fork是一项很消耗时间和资源的工作。

FastCGIFastCGI是可伸缩架构的CGI开放扩展，
其主要行为是将CGI解释器进程保持在内存中并因此获得较高的性能。
传统的CGI 解释器的反复加载是CGI性能低下的主要原因，
如果CGI解释器保持在内存中并接受FastCGI进程管理器调度，
则可以提供良好的性能、伸缩性等 。在上述情况中，你可以想象 CGI通常有多慢。
每一个Web请求PHP都必须重新解析php.ini、重新载入全部扩展并重初始化全部数据结构。
使用FastCGI，所有这些 都只在进程启动时发生一次。一个额外的好处是，
持续数据库连接(Persistent database connection)可以工作。

在lamp体系中，对于apache端的php的配置，我们最常用的就是mod_php，
它把php作为apache一个内置的模块.让apache http服务器本身能够支持php语言，
不需要每一个请求就启动php解释器来解释php.

和把webserver与php绑定起来的方式不同，
fastcgi是http服务器与你的或其它机器上的程序进行“交谈”的一种工具，
相当于一 个程序接口。它可以接受来自web服务器的请求，解释输入信息，
将处理后的结果返回给服务器等。mod_fastcgi就是在apache下支持 fastcgi协议的模块。

在lamp体系中，mod_php是最常使用的工作方式。在这种模式下，
php被编译为apache的一个内置模块，在启动加载的时候，
当有一个php请求过来，直接在httpd进程里完成了php的解释运行，将结果返回。

mod_fastcgi就是在apache下支持 fastcgi协议的模块。
fastcgi实例和apache分离开来，这两者可以分开来部署。
他们之间的通信通过tcp或者unix sock来完成。使用ext方式，
fastcgi实例是独立运行的。

FPM（FastCGI 进程管理器）用于替换 PHP FastCGI 的大部分附加功能，
对于高负载网站是非常有用的。

官方的定义中：生成器就是简单的迭代器。
不同于标准的PHP迭代器，PHP的生成器并不要求你一定要在一个重量级的类中实现Iterator接口。
相反，生成器会按需求计算并交出迭代值。这对应用程序的性能有着深远的意义。想想吧，
一个标准的PHP迭代器通常都是基于内存中全部计算过的数据集进行迭代。这样做效率不高。
尤其是大量可计算的公式化数据集。使用生成器我们可以动态的计算并交出下一个值而不占用
宝贵的系统内存，这就是我们使用生成器的原因。

<?php  
function myGenerator() {  
    yield 'value1';  
    yield 'value2';  
    yield 'value3';  
}  

<?php  
foreach (myGenerator() as $yieldedValue) {  
    echo $yieldedValue, PHP_EOL;  
}  

<?php  
function makeRange($length) {  
    $dataset = [];  
    for ($i = 0; $i < $length; $i++) {  
        $dataset[] = $i;  
    }  
  
    return $dataset;  
}  
  
$customRange = makeRange(1000000);  
foreach ($customRange as $i) {  
    echo $i, PHP_EOL;  
}  

<?php  
function makeRange($length) {  
    for ($i = 0; $i < $length; $i++) {  
        yield $i;  
    }  
}  
  
foreach (makeRange(1000000) as $i) {  
    echo $i, PHP_EOL;  
}  

<?php  
function getRows($file) {  
    $handle = fopen($file, 'rb');  
    if ($handle === false) {  
        throw new Exception();  
    }  
    while (feof($handle) === false) {  
        yield fgetcsv($handle);  
    }  
    fclose($handle);  
}  
  
foreach (getRows('data.csv') as $row) {  
    print_r($row);  
}  

function printer()
{
    while (true) {
        printf("receive: %s\n", yield);
    }
}

$printer = printer();

$printer->send('hello');
$printer->send('world');

<?php

/**
* Iterator模式的简单实现类
*/
class sample implements Iterator {
    private $_items ;
 
    public function __construct(&$data) {
        $this->_items = $data;
    }
    public function current() {
        return current($this->_items);
    }
 
    public function next() {
        next($this->_items);   
    }
 
    public function key() {
        return key($this->_items);
    }
 
    public function rewind() {
        reset($this->_items);
    }
 
    public function valid() {                                                                              
        return ($this->current() !== FALSE);
    }
}
 
/** DEMO */
$data = array(1, 2, 3, 4, 5);
$sa = new sample($data);
foreach ($sa AS $key => $row) {
    echo $key, ' ', $row, '<br />';
}

?>

<?php   
class sample implements Iterator
{
    private $_items = array(1,2,3,4,5,6,7);
 
    public function __construct() {
                  ;//void
    }
    public function rewind() { reset($this->_items); }
    public function current() { return current($this->_items); }
    public function key() { return key($this->_items); }
    public function next() { return next($this->_items); }
    public function valid() { return ( $this->current() !== false ); }
}
 
$sa = new sample();
foreach($sa as $key => $val){
    print $key . "=>" .$val;
}
?> 

使对象可以像数组一样进行foreach循环，要求属性必须是私有。

class sample implements Iterator
{
    private $_items = array(1,2,3,4,5,6,7);

    public function __construct() {
        ;//void
    }
    public function rewind()
    {
        reset($this->_items);
    }
    public function current()
    {
        return current($this->_items);
    }
    public function key()
    {
        return key($this->_items);
    }
    public function next()
    {
        return next($this->_items);
    }
    public function valid()
    {
        return ( $this->current() !== false );
    }
}

$sa = new sample();
foreach($sa as $key => $val){
    print $key . "=>" .$val.'<br>';
}

class User
{
    public $a = 'tom';
    protected  $b = 'lilei';
    private  $c = 'hanmeimei';
    public function __construct()
    {
    }
}

foreach (new User() as $user){
    echo $user.'<br>';
}

class User
{
    public $a = 'tom';
    protected  $b = 'lilei';
    private  $c = 'hanmeimei';
    public function do_something() {
        foreach($this as $key => $value) {
            echo "$key => $value\n";
        }
    }
}

$user = new User();
$user->do_something();

composer require rcrowe/twigbridge

'providers' => [
     ...
                TwigBridge\ServiceProvider::class,
],
'aliases' => [
    ... 
                'Twig' => TwigBridge\Facade\Twig::class,
],

php artisan vendor:publish --provider="TwigBridge\ServiceProvider"

//返回视图
Route::get('test',function (){
    $users = \App\User::all();
    return view('hello',compact('users'));
});
//新建视图文件resources/views/hello.twig
<body>
    {%  for user in users %}
        {{ user.name }}
    {%  endfor %}
</body>

MySQL的内存表，表结构创建在磁盘上，数据存放在内存中，所以当MySQL启动着的时候，
这个表是存在的，数据也是存在的，当MySQL重启后，数据消失，表结构还存在（
临时表表结构及数据都在内存中）。内存表最大所需内存需要通过
max_heap_table_size=1024M设定，临时表最大所需内存需要通过tmp_table_size = 1024M
设定。当数据超过临时表的最大值设定时，自动转为基于磁盘的MyISAM表，
存储在指定的tmpdir目录，此时因需要进行IO操作，性能会大大下降，
而内存表不会，内存表满后，会提示数据满错误。

内存表的表定义是存放在磁盘上的，扩展名为.frm， 重启不会丢失。
内存表的数据是存放在内存中的，重启会丢失数据。
MEMORY表使用一个固定的记录长度格式。
mysql重启后，主键、自增、索引仍然存在，只是数据丢失。

内存表使用哈希散列索引把数据保存在内存中，因此具有极快的速度。

内存表不能包含BLOB或者TEXT列。
内存表不支持事务。
内存表是表锁，当修改频繁时，性能可能会下降。
内存表数据清空或删除表后占用内存不会自动释放。

// 声明class User
class User{
    $id;
    $name;

    function create(){/*...*/}
    function load($id){/*...*/}
}

// 使用class User
$user = new User();
$user->name = 'fancy';
$user->create();

// 直接使用！对于熟悉MVC的亲知道这个意义之所在！
$user = new ORM('user');  // ORM都有自己的规则，这里直接使用了MySQL的表名
$user->name = 'fancy';    // MySQL的表的字段就是$user对象的成员变量
$user->save();            // 掉用ORM提供的接口函数