Shells can have variables of 2 types: locals, which are only accessible from the current shell, and (exported) environment variables, which are passed on to every executed program. set can see shell-local variables, env cannot.

Since set is a built-in shell command, it also sees sees shell-local variables (including shell functions). env on the other hand is an independent executable; it only sees the variables that the shell passes to it, or environment variables.

When you type a line like a=1 then a local variable is created (unless it already existed in the environment). Environment variables are created with export a=1

What we have here the difference between environment variables and shell variables. Under sh (and variants) all environment variables are automatically shell variables as well, but the same is not true in the other direction (this originally was to save memory (I think)).

Environment variables are stored in an area of memory that is kept when a process calls exec(), this means that programs you run from the command line get a copy of the environment. Shell variables do not stay over an exec(), but are copied in a fork(). When you create a subshell the shell calls fork() in order to copy the present process, but it does NOT call exec() because the process it requires is already there thus the shell variables are kept.

Also most shells set for you certain shell variables when you start them up, PS1 is a perfect example of this, and you may have also set them yourself in your shell initalisation file.

In summary, shell variables are used by the shell and copies it makes of itself, while environment variables are used by everything.

• 使用不受信任的 ppa, 安装不受支持的软件.

1
2
3

sudo add-apt-repository ppa:jonathonf/vim
sudo apt-get update
sudo apt-get install vim

• 删除 vim

1

sudo apt-get remove vim

转载

1
2
3
4
5
6

for VARIABLE in 1 2 3 4 5 .. N
do
  command1
  command2
  commandN
done

1
2
3
4
5
6

for VARIABLE in file1 file2 file3
do
  command1 on $VARIABLE
  command2
  commandN
done

1
2
3
4
5
6

for OUTPUT in $(Linux-Or-Unix-Command-Here)
do
  command1 on $OUTPUT
  command2 on $OUTPUT
  commandN
done

1
2
3
4
5
6

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

1
2
3
4
5

#!/bin/bash
for (( c=1; c<=5; c++ ))
do
 echo "Welcome $c times"
done

1
2
3
4
5

#infinite loops
for (( ; ; ))
do
  echo "infinite loops [ hit CTRL+C to stop]"
done

1
2
3
4
5
6
7
8
9
10

#!/bin/bash
for file in /etc/*
do
  if [ "${file}" == "/etc/resolv.conf" ]
  then
    countNameservers=$(grep -c nameserver /etc/resolv.conf)
    echo "Total  ${countNameservers} nameservers defined in ${file}"
    break
  fi
done

1
2
3
4
5
6
7
8
9
10
11
12
13

#!/bin/bash
FILES="$@"
for f in $FILES
do
  # if .bak backup file exists, read next file
  if [ -f ${f}.bak ]
  then
    echo "Skiping $f file..."
    continue  # read next file and skip cp command
  fi
  # we are hear means no backup file exists, just use cp command to copy file
  /bin/cp $f $f.bak
done

• 名字

  1 2	find . -name "lizhen.c"; find / -iname "lizhen.c"

• 目录深度

  1 2	find -maxdepth 2 -name passwd ; find / -mindepth 3 - maxdepth 5 -name passwd

• 反向

  1	find -not -iname "lizhen.c"

• 执行命令

  1	find -iname "lizhen.c" -exec md5sum {} \;

• 文件权限

  1	find. -perm -g=r -type f -exec ls -l {} \;

• 空文件

  1	find ~ -empty

• 大小

  1	find ~ -size +100M

• Top 5 Big files

  1	find . -type f -exec ls -s {} \; | sort -n -r | head -5

• find files by comaring with the modification time of other file

  1	find -newer ordinary_file

• 最近几天没有修改的文件

  1	find . -mtime +60

• xargs

  1	find ~ -name '*.log' -print0 | xargs -0 cat

  备注: xargs 默认是以空白字符 (空格, TAB, 换行符) 来分割记录的,当这些不能分割时需设置为NULL分割.

我们知道在Linux中取出变量使用$符号，当我第一次看到表达式PATH=$PATH:/usr/game时，我不能理解Shell是如何将字符串连接起来的,按照使用其他语言的经验，没有字符串连接运算符啊，后来偶然查到资料，前述表达式实际上就是PATH=”$PATH:/usr/game”，省略害死人。

• 在传统的OO语言中，函数的上下文是由声明函数时确定的，例如静态函数通过类名调用，上下文是类。非静态函数通过类的实例调用，上下文是类的实例。而在javascript中函数首先是一个对象，它的上下文不能由声明时确定，而是由谁来调用来确定。也可通过使用call()和apply()来强行指定上下文。
• 闭包就是一个函数实例，该实例执行时需要的局部变量，来自其声明处。

我们知道计算机只能识别0和1, 当我们在SQL SERVER中保存和读取字符时就遇到了编码问题，SQL中字符从编码角度来看可分为2类，Unicode (nchar ,nvarchar)和非Unicode(char ,varchar) ,对于Unicode来说每个字符的码是一样的，不同语言不同版本的工具处理Unicode不存在问题。对于非Unicode 的字符，每个字符的码不一样，依赖于所属的代码页，只有知道了代码页，才能正确解释构成字符的0和1。而查询Collations就能得到代码页，同时Collations 对所有的Unicode 和非Unicode 规定了排序规则：大小写、重音、假名等。对于nvarchar ,nchar来说无关Collations中的代码页。

• A class should have only a single responsibility
  单一职责(S): 一个类只承担一个职责,引起类变化的因素永远不要多余一个.
• A class should be open for extension but closed for modification
  开闭原则(O): 不需要修改就能扩展类的行为,对拓展开放，对修改关闭.
• A type must be substitutable by its subtypes without altering the correctness of the application
  替换原则(L): 子类代替父类时，对系统毫无影响,所有引用基类的地方必须能透明地使用其子类的对象.
• Clients of a class should not be forced to depend on those of its methods that they don’t use
  接口隔离(I):客户端不应该强制依赖那些他们没有使用到的接口,类不需强制实现接口中不需要的方法和属性.
• High-level classes should not dependent on low-level classes. Both of then shoud depend on abstractions. b. Abstractions should not depend upon details. Details should depend upon abstractions.
  依赖倒置(D):上级组件不依赖下级组件，二者都依赖抽象。抽象不取决于下级组件，其来自于上级组件的需求,下级组件完成抽象.

Javascript 的this绑定使用时容易混淆，是语言的一个设计失误。而Js的闭包是这门语言的精髓。其实this是由函数的调用方式决定的，this代表函数执行时的上下文，而函数的调用有五种

1
2
3
4
5
6
7
8
9
10
11

function ex1(name) {}
function Obj(name) {}
var obj = {
  ex1: function() {}
};

ex1('li'); //直接调用
obj.ex1('li'); //方法调用
objnew = new Obj('li'); //构造器
ex1.call(objnew ,'li'); //call方法
ex1.apply(objnew ,['li']);  // apply 方法

• 函数直接执行: 严格模式下是undefine,非严格模式是global context.(浏览器中是Window对象).
• 函数做为对象的方法被调用: this绑定到对象.
• 函数做为构造器被调用(new): this绑定到创建的对象
• call / apply 调用时可指定this对象.

两种执行方式
-n 禁止默认输出

1
2

sed [-n] [-e] 'command' file(s)
sed [-n] -f scriptfile file(s)

command结构

1
2
3
4
5

- [addr [,addr]] [!] action [arguments]
- [/pattern/[,/pattern/]] {
  cmd
  cmd
}

action

• a 拼接
• c 替换
• i 插入
• d 删除
• s 替换
• y 翻译
• p 打印

举例

1
2
3
4
5
6
7
8
9
10
11

# only print
sed -ne '/regexp/p' inputfile(s)
sed -n '/GREEN/,$p' inputfile(s)

# append after the pattern (-i 直接修改源文件)
sed -i '/pattern/a \
line1 \
line2' inputfile

# insert before the pattern
sed -i '/This is line two/i\your text 1\nyout text 2' inputfile(s)