$ who am i  # 伪终端的用户名 伪终端序号(pts/0) 打开时间
$ who -a	# 打印能打印的全部
$ who -d	# 打印死掉的进程
$ who -m	# 同am i,mom likes
$ who -q	# 打印当前登录用户数及用户名
$ who -u	# 打印当前登录用户登录信息
$ who -r	打印运行等级

sudo adduser mars # 默认生成的 用户组 和 用户名 相同

su -l mars

groups mars

$ su -l mars # 切换登录用户
$ sudo ls

$ groups mars
$ sudo usermod -G sudo mars
$ groups mars

sudo deluser mars --remove-home

$ sudo chown [新用户名] [文件名]

$ chmod 700 iphone6 # 现在，其他用户已经不能读这个“ iphone6 ”文件了

$ chmod go-rw iphone6

cd ~
mkdir .ssh
cd .ssh
vim authorized_keys # 将本机id_rsa.pub中的key粘贴进去

$ ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

$ [sudo] apt-get update  
$ [sudo] apt-get install nginx

$ cd /etc/nginx/conf.d
$ vim nodeChinaClub.conf

sudo service nginx reload

sudo service nginx start
sudo service nginx stop
sudo service nginx restart

upstream wedesign {
  server unix:///mnt/www/wedesign/shared/tmp/sockets/puma.sock;
}

server {
  listen 80;
  server_name rails.itrydo.com; # change to match your URL
  root /mnt/www/wedesign/shared/public/assets; # I assume your app is located at that location

  location / {
    proxy_pass http://wedesign; # match the name of upstream directive which is defined above
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  }

  location ~* ^/assets/ {
    # Per RFC2616 - 1 year maximum expiry
    expires 1y;
    add_header Cache-Control public;

    # Some browsers still send conditional-GET requests if there's a
    # Last-Modified header or an ETag header even if they haven't
    # reached the expiry date sent in the Expires header.
    add_header Last-Modified "";
    add_header ETag "";
    break;
  }
}

sudo ln -sf /etc/nginx/sites-available/wedesign.conf /etc/nginx/sites-enabled/wedesign.conf

sudo nginx -t -c /etc/nginx/nginx.conf

bundle exec puma -e production -b unix:///mnt/www/wedesign/shared/tmp/sockets/puma.sock
# 后台启动 -d
bundle exec puma -e production -d -b unix:///mnt/www/wedesign/shared/tmp/sockets/puma.sock

sudo apt-get install git

sudo apt-get install rbenv ruby-build

git clone https://github.com/rbenv/rbenv.git ~/.rbenv
cd ~/.rbenv && src/configure && make -C src
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
~/.rbenv/bin/rbenv init
exec $SHELL
# 安装ruby-build
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
# 通过 gem 命令安装完 gem 后无需手动输入 rbenv rehash 命令, 推荐
git clone git://github.com/sstephenson/rbenv-gem-rehash.git ~/.rbenv/plugins/rbenv-gem-rehash
# 通过 rbenv update 命令来更新 rbenv 以及所有插件, 推荐
git clone git://github.com/rkh/rbenv-update.git ~/.rbenv/plugins/rbenv-update
# 使用 Ruby China 的镜像安装 Ruby, 国内用户推荐
git clone git://github.com/AndorChen/rbenv-china-mirror.git ~/.rbenv/plugins/rbenv-china-mirror

sudo apt-get install -y libssl-dev libreadline-dev zlib1g-dev
rbenv install 2.4.1
rbenv versions
rbenv local 2.4.1
gem install bundler

sudo netstat -tap | grep mysql

sudo apt-get install mysql-server mysql-client libmysqlclient-dev

sudo netstat -tap | grep mysql

mysql -uroot -p

# 启动MySQL服务：                       
sudo service mysql start 
# 停止MySQL服务：                       
sudo service mysql stop
# 修改 MySQL 的管理员密码：     
sudo mysqladmin -u root password newpassword
# 设置远程访问(正常情况下，mysql占用的3306端口只是在IP 127.0.0.1上监听，拒绝了其他IP的访问（通过netstat可以查看到）。取消本地监听需要修改 my.cnf 文件：)：    
sudo vi /etc/mysql/my.cnf
bind-address = 127.0.0.1 //找到此内容并且注释

# 数据库存放目录：               
/var/lib/mysql/
# 相关配置文件存放目录：          
/usr/share/mysql
# 相关命令存放目录：             
/usr/bin(mysqladmin mysqldump等命令)
# 启动脚步存放目录：            
/etc/rc.d/init.d/

Navicat
Sequel pro

sudo apt-get install nodejs

cd /mnt/www/wedesign/current
# then run 
rake db:create RAILS_ENV=production

#!/usr/bin/env puma

environment "production"

daemonize true
workers 2
threads 2,16

bind "unix:///mnt/www/wedesign/shared/tmp/sockets/puma.sock"

pidfile "/mnt/www/wedesign/shared/tmp/pids/puma.pid"
state_path "/mnt/www/wedesign/shared/tmp/sockets/puma.state"

stdout_redirect '/mnt/www/wedesign/shared/log/stdout', '/mnt/www/wedesign/shared/log/stderr'

directory "/mnt/www/wedesign/current"

activate_control_app 'unix:///mnt/www/wedesign/shared/tmp/sockets/pumactl.sock'

prune_bundler

default: &default
  adapter: mysql2
  encoding: utf8
  pool: 5
  username: root
  password:
  host: localhost
production:
  <<: *default
  database: [project_database_name]
  username: [database_username]
  password: [database_password]

production:
  #secret_key_base: <%= ENV["SECRET_KEY_BASE"] %>
  # or run rake secret
  secret_key_base: [secret_key]

upstream wedesign {
  server unix:///mnt/www/wedesign/shared/tmp/sockets/puma.sock;
}

server {
  listen 80;
  server_name rails.itrydo.com; # change to match your URL
  root /mnt/www/wedesign/shared/public; # I assume your app is located at that location

  location / {
    proxy_pass http://wedesign; # match the name of upstream directive which is defined above
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  }

  location ~* ^/assets/ {
    # Per RFC2616 - 1 year maximum expiry
    expires 1y;
    add_header Cache-Control public;

    # Some browsers still send conditional-GET requests if there's a
    # Last-Modified header or an ETag header even if they haven't
    # reached the expiry date sent in the Expires header.
    add_header Last-Modified "";
    add_header ETag "";
    break;
  }
}

$ sudo ln -sf /etc/nginx/sites-available/wedesign.conf /etc/nginx/sites-enabled/wedesign.conf

var vm = new Vue({
	el: 'body',
    data: {
    	a: 1
    },
    // 计算属性
    computed: {
    	b: function(){ //默认是get
        	return this.a + 1;
        },
        c: {
        	get: function(){
            	return this.a + 1;
            }
            set: function(val){
            	this.a = val;
            }
        }
    },
    // 过滤器@1.x currency capitalize uppercase downcase debounce(ms) limitBy(count, index=0) filterBy(str) orderBy(1/-1) ...
    fileters: {
    
    },
    
    // @1.x transition
    // 动画过度 可通过类定义，也可使用transitions
    // <div class="animated" v-show="toggle" transition="bounce"></div>
    // 这里的class animated是animate.css做动画必须类！
    transitions: {
    	bounce: {
        	enterClass: 'zoomInLeft',
            leaveClass: 'zoomOutRight'
        }
    },
    
    // @2.x transition
    // .fade-enter{} // 初始状态
    // .fade-enter-active{} //变化成的状态->显示
    // .fade-leave{}
    // .fade-leave-active{} //变化成的状态->离开(消失)
    <transition name="fade" @before-enter="beforeEnter()" @enter="enter()" @after-enter="afterEnter" @before-leave="beforeLeave" @leave="leave" @after-leave="afterLeave">
    	<p></p>
    </transition>
    
    //2.x 结合animate.css使用
    <transition enter-active-class="zoomInLeft" leave-active-class="bounceOutRight">
    	<p class="animated" v-show="show"></p>
    </transition
    
    created: function(){}, // 创建之后
    beforeCompile: function(){}, // 编译之前 @1.x
    compiled: function(){}, // 变异之后 @1.x
    ready: function(){}, //节点插入到文档 @1.x
    
    beforeDestroy: function(){}, //销毁之前
    destroyed: function(){} // 销毁之后
})
vm.$el // 元素
vm.$data // data本身
vm.$mount // 手动挂载Vue程序
vm.options // 获取自定义属性对象
vm.$destroy // 销毁对象
vm.$log() // 查看当前数据状态

// 全局自定义过滤器
Vue.filter('toDouble', function(val){
	return val * 2;
});
// 双向过滤器 v-model 
Vue.filter('modelVal', {
	read: function(val){
    	return val
    },
    write: function(val){
    	return val;
    }
})

// 全局自定义指令
// <span v-red>abc</span>
Vue.directive('red', function(){
	//this.el 绑定该指令的元素(原生dom元素)
    this.el.style.background = 'red';
});
// 自定义元素指令 elementDirective

// 自定义键盘
// @keydown.ctrl = "show()"
// @keydown.mycustomenter = "show()"
Vue.directive('on').keyCodes.ctrl = 17 // @1.x
Vue.directive('on').keyCodes.mycustomenter = 13 //@1.x
// Vue.config.keyCodes.ctrl=17 //@2.x

// 监听数据变化
vm.$watch('a', function(){});
// vm.$watch('obj', function(){}, {deep: true});检测对象

<body>
    <div id="box">
        <custom></custom>
    </div>
    <script>
    	// only: vue@1.x can use
        var Custom = Vue.extend({
        	data: function(){
            	return {
                	title: '我是自定义标题'
                }
            },
            template: '<h3>{{title}}</h3>'
        })
        Vue.component('custom', Custom);
        
        var vm = new Vue({
            el: '#box',
        })
    </script>
</body>

Vue.component('custom', {
	template: '<h3>我是自定义模板</h3>'
})

var Custom = Vue.extend({
    template: '<h3>我是自定义模板</h3>'
})

var vm = new Vue({
    el: '#box',
    components: {
    	custom: Custom
    }
})

new Vue({
    el: '#box',
    components: {
        custom: {
            template: '<h3>我是自定义模板</h3>'
        }
    }
})

<template id="custom">
    <h3>我是自定义模板</h3>
</template>
<script>
    new Vue({
        el: '#box',
        components: {
            custom: {
                template: '#custom'
            }
        }
    })
</script>

<body>
    <div id="box">
        <component :is="custom"></component>
    </div>
    <script>
        new Vue({
            el: '#box',
            data: {
                custom: 'a'  
            },
            components: {
                a: {
                    template: '<h1>我是a</h1>'
                },
                b: {
                    template: '<h1>我是b</h1>'
                }
            }
        })
    </script>
</body>

<body>
    <div id="box">
    	// @1.x中 .sync子组件更改，同步到父组件
        // @2.x中，不允许使用.sync了
        <custom :root.sync="root" :my-msg="msg"></custom>
    </div>
    <script>
        var vm = new Vue({
            el: '#box',
            data: {
            	root: 'root var'
                msg: 'my msg'
            },
            components: {
            	custom: {
				    props: ['root', 'myMsg'],
                	template: '<h3>{{root}} - {{myMsg}}</h3>'
                }
            }
        })
    </script>
</body>

<body>
    <div id="box">
        <custom @child-msg="get"></custom>
    </div>
    <script>
        var vm = new Vue({
            el: '#box',
            data: {},
            methods: {
            	get: function(msg){
                	// msg: 'sub title'
                }
            },
            components: {
            	custom: {
	                template: '<h3>{{title}}</h3>'
                    data: function(){
                    	return {
                        	title: 'sub title'
                        }
                    },
                    methods: {
                    	send: function(){
                        	this.$emit('child-msg', this.title)
                        }
                    }
                }
            }
        })
    </script>
</body>

<body>
    <div id="box">
        <custom>
            <p>I'm use slot</p>
        </custom>
    </div>
    <template id="custom">
        <h3>我是自定义模板</h3>
        <slot>为空的默认值</slot>
        <p>footer</p>
    </template>
    <script>
        new Vue({
            el: '#box',
            components: {
                custom: {
                    template: '#custom'
                }
            }
        })
    </script>
</body>

<custom>
	<p slot="slot1">I'm use slot</p>
    <p slot="slot2">I'm use slot</p>
</custom>
<template id="custom">
	<h3>我是自定义模板</h3>
	<slot name="slot1">为空的slot1默认值</slot>
    <slot name="slot2">为空的slot2默认值</slot>
	<p>footer</p>
</template>

def foo
  a = 3
  yield a
end

foo {|b| puts b}

def foo(&block)
  a = 2
  block.call(a)
end

foo {|a| puts a}

proc = Proc.new {|x| x*2}

lambda = lambda {|x| x*2}

## diff1
p = Proc.new {|x, y| p x,y}
p.call(1)    # 1, nil
p.call(1,2)  # 1,2
p.cal(1,2,3) # 1,2

l = lambda {|x,y| p x,y}
l.call(1)     # err
l.call(1,2)   # 1,2
l.call(1,2,3) # err

## diff2
p = Proc.new {|x| return x}
p.call(1) # err

l = lambda {|x| return x}
p.call(1) # 1

class Point
  attr_accessor :x  # getter setter
  attr_reader :y    # getter
  @@origin = 0
  ORIGIN = 2 # 常量    # 取值 Point::ORIGIN
  def initialize(x = 0, y = 0)
    # @x 实例变量
    # @@x 类变量
    # $x 全局变量
    # x 局部变量
    @x = x
    @y = y
  end

  # 实例方法
  def +(p2)
    Point.new(x+p2.x, y+p2.y)
  end

  # 类方法
  def self.foo
  end

  # 内部定义的都是类方法
  class << self
    def bar
    end
  end
end

class Point3D < Point
  def initialize(x=0, y=0, z=0)
    # @x, @y, @z = x, y , z
    super(x, y)
    @z = z
  end
end

def foo
  begin
    # raise "boom in foo"
    raise TypeError, "boom in foo", caller
  rescue => e
    puts e
  end
end

class People
  attr_reader :name
  include Comparable
  def initialize name
    @name = name
  end
  def <=> other
    self.name <=> other.name
  end
end

class People
  attr_reader :people
  include Enumerable
  def initialize people
    @people = people
  end
  def each
    raise "please provide a block" unless block_given?
    people.each do |person|
      yield person
    end
  end
end

"ruby" =~ /ruby/  # 0
"ruby".match(/ru/) # ru
"ruby".gsub!(/r/, i) # iuby

[abc]	A single character of: a, b, or c
[^abc]	Any single character except: a, b, or c
[a-z]	Any single character in the range a-z
[a-zA-Z]	Any single character in the range a-z or A-Z
^	Start of line
$	End of line
\A	Start of string
\z	End of string
.	Any single character
\s	Any whitespace character
\S	Any non-whitespace character
\d	Any digit
\D	Any non-digit
\w	Any word character (letter, number, underscore)
\W	Any non-word character
\b	Any word boundary
(...)	Capture everything enclosed
(a|b)	a or b
a?	Zero or one of a
a*	Zero or more of a
a+	One or more of a
a{3}	Exactly 3 of a
a{3,}	3 or more of a
a{3,6}	Between 3 and 6 of a

options: 
i case insensitive 
m make dot match newlines 
x ignore whitespace in regex 
o perform #{...} substitutions only once

def foo
  Thread.current['a'] = 1
  10.times do
    puts 'foo'
  end
end

def bar
  10.times do
    puts 'bar'
  end
end

t1 = Thread.new {foo()}
t2 = Thread.new {bar()}
t1.join
t2.join # 这里主线程等待t1,t2执行完成，才继续主线程执行，否则主线程停止，子线程将被释放

puts t1['a'] # 1

mutex = Mutex.new
count1 = count2 = 0
Thread.new do
loop do
   	mutex.synchronize do # 类似ios的线程锁！
       	count1 += 1
           count2 += 1
       end
   end
end
sleep(1)
mutex.lock

eval "1 + 1"
eval "def foo; puts 'foo'; end"

String.instance_eval "def foo; puts 'instance_eval foo'; end"
String.foo #输出 instance_eval foo

String.class_eval "def foo; puts 'class_eval foo'; end"
str = 'abc'
str.foo #输出： class_eval foo

define_method(:foo) { puts 'abc' }
# 带一个参数的方法定义
define_method(:foo) {|arg| puts arg }

def method_missing method_name
self.class.send(:define_method, method_name){
	puts method_name
   }
end

$ rails new wechat
$ rails new wechat [--skip-bundle] # skip bundle install
$ rails new wechat -d mysql # use mysql as database

rails g model User username:string phone:string:index age:integer

bundle exec rake db:migrate
bundle exec rake db:rollback
# 回滚两步
bundle exec rake db:rollback STEP=2

rails c

$ rails g model User phone:string:index email:string age:integer

$ rails g controller users index new edit show

$ bundle exec rake db:migrate

$ bundle exec rake db:rollback

class User < ActiveRecord::Base
  # 存在验证唯一，或者可以为空
  validates :phone, uniqueness: {allow_nil: true} # method1
  validates :phone, uniqueness: {allow_blank: true} # method2
  # 条件验证1[fun] 仅仅方法返回true才进行验证
  validates :phone, uniqueness: true, :if => :test?
  def test?
    false
  end 
  # 条件验证2[string] 用户名为空进行验证
  validates :phone, uniqueness: true, :if => "name.nil?"
  # 条件验证3[proc]
  validates :phone, uniqueness: true, :if => Proc.new {name.nil?}
  # 条件验证 test? 成立  才会内部代码块的验证
  with_options if: :test? do
    validates :name, presence: true
    validates :phone, presence: true
  end
  def test? do
    (1+1 == 2)
  end
end

class User < ActiveRecord::Base
	validate :my_validator
    def my_validator
    	if name.nil?
        	errors[:name] << '姓名不能为空'
        end
    end
end

u = User.new
u.valid?      # if false
u.errors.messages # return hash
u.errors[:name] # name属性不合法的信息描述

# 创建
u = User.new
# 验证
u.valid?
# 查看验证错误信息
u.errors.messages
# 添加name属性的错误信息
u.errors[:name] < '用户名不能为空'
# 等价于
u.errors.add(:name, '用户名不能为空')
# 查看错误条数
u.errors.size

class User < ActiveRecord::Base
	# 仅仅当创建的时候执行AfterCommit
	after_commit :AfterCommit, on: :create
    # test? 为真， 才会执行BeforeSave
	before_save :BeforeSave, if: :test?
    def test?
    	true
    end
    def BeforeSave 
    	puts 'before_save'
    end
end

rvm list

rvm install ruby 2.2.2

rvm use 2.2.2

$ gem sources -l

$ gem sources --remove https://rubygems.org/

$ gem source -a https://gems.ruby-china.org

$ gem install rails -v 4.2.3

$ rails new [myPro] [--skip-bundle]

# 手动配置posts的show路由   as配置路由名称
  # get 'posts/:id', :to => 'posts#show', :as => 'show_post'

  #  排除show路由
  # resources :posts, :except => :show

  resources :posts do
    # posts/recent
    # get 'recent', :on => :collection
    #  集合路由
    collection do
      # posts/recent
      get 'recent'
    end
    #  成员路由
    member do
      # posts/:id/recent
      get 'recent'
    end
  end

// underscore v1.7.0相关的源码剖
_.debounce = function(func, wait, immediate) {
    // immediate默认为false
    var timeout, args, context, timestamp, result;

    var later = function() {
      // 当wait指定的时间间隔期间多次调用_.debounce返回的函数，则会不断更新timestamp的值，导致last < wait && last >= 0一直为true，从而不断启动新的计时器延时执行func
      var last = _.now() - timestamp;

      if (last < wait && last >= 0) {
        timeout = setTimeout(later, wait - last);
      } else {
        timeout = null;
        if (!immediate) {
          result = func.apply(context, args);
          if (!timeout) context = args = null;
        }
      }
    };

    return function() {
      context = this;
      args = arguments;
      timestamp = _.now();
      // 第一次调用该方法时，且immediate为true，则调用func函数
      var callNow = immediate && !timeout;
      // 在wait指定的时间间隔内首次调用该方法，则启动计时器定时调用func函数
      if (!timeout) timeout = setTimeout(later, wait);
      if (callNow) {
        result = func.apply(context, args);
        context = args = null;
      }

      return result;
    };
  };

  /**
 * 包裹函数 一段时间间隔只执行函数一次
 * @param funcRef 函数引用
 * @param wait default, 300ms
 * 是否立即触发，触发后wait时间内不触发该方法，wait时间后才可以重新触发
 * false：wait后触发  没有返回值
 * true: wait前触发, 可以有返回值
 * @param immediate default false
 * return : 返回新的函数，使用：将需要调用funcRef的地方，替换为调用新返回的函数即可
 */
function debounce(funcRef, wait, immediate) {
    var context, args, timestamp, timeout;
    wait = wait || 300;
    return function () {
        context = this;
        args = arguments;
        timestamp = new Date().getTime();
        var nowCall = immediate && !timeout;
        if(!timeout){
            timeout = setTimeout(later, wait)
        }
        if(nowCall){
            var result = funcRef.apply(context, arguments);
            context = args = null;
            return result;
        }
    };
    function later() {
        // 当wait指定的时间间隔期间多次调用_.debounce返回的函数，则会不断更新timestamp的值，导致last < wait && last >= 0一直为true，从而不断启动新的计时器延时执行func
        var last = new Date().getTime() - timestamp;
        if (last < wait && last >= 0) {
            timeout = setTimeout(later, wait - last);
        }else {
            timeout = null;
            if (!immediate) {
                funcRef.apply(context, args);
                if (!timeout) context = args = null;
            }
        }
    }
}

#git reset --hard HEAD~1 # 取消当前版本之前的一次提交
git reset --hard HEAD~2 # 取消当前版本之前的两次提交
git push origin HEAD --force # 强制提交到远程版本库，从而删除之前的两次提交数据

git config --global credential.helper osxkeychain