括号是数学中最常用的符号之一。括号不仅能使我们的公式更加美观，还能使我们的表达更为清晰、丰富。
latex里面的括号和我们常见的括号是一样的，主要是小括号、中括号（或者叫方括号）和花括号。这里我们看到花括号如果直接打出来的话是不显示任何东西的，这里我们需要加一个转义符，也就是反斜杠。
如果只用直接的括号字符，只能打出固定大小的括号，比如这样打出的括号就比较小。
那么如何打出更大一点的括号呢？
在latex里，只要是左、右“夹”起来的符号都可以加上"left"和"right"关键词，这样它就会自动地适应大小。
不过要记住，花括号仍然是要加上转义符，直接在左右两边加上"left"和"right"关键词它就会自动适应大小。
刚刚我们说了，只要是左右“夹”起来的符号都可以这样用，我们来试试其它的符号。
写一个比较大的绝对值符号
注意，在latex里面，所有的"left"和"right"必须成对出现，否则就会报错。
如果只想写一边，另外一边啥也没有，可以用点来代替另一边的符号，就像这样：
也可以强行控制括号的大号，而不是自适应
那么在latex里，字体的大小其实可以灵活地处理，大家需要用的时候可以直接去查这个表就行了。
接下来我们来说另一个更为复杂的问题，如何进行上、下括号并且加入附带的文字、公式内容。
之前我们说过，latex的关键词就是常用的说法的英文，有时候直接就是全称。上下括号的英文就是overbrace和underbrace。注意这里为什么是overbrace而不是upbrace，因为over是表示“顶”在某个东西的上面，比如1/3其实就是one over three。所以知道这一点，也就不难记了。
而在上下括号加上其它的内容也很简单，就是上下标。
注意，上面我们看到的是常见的打法。对于上、下括号这种特殊的符号，它们的上下标就被设置成了正上和正下方，不再是我们普通符号默认的右上右下方。明白这一点后我们也可以打出更有意思的内容。有了这样的用法，是不是就觉得我们加一些备注信息就更容易了呢。
关注我们分享更多有趣有用的知识哟~

[

     {"keys": ["enter"], "command": "move", "args": {"by": "characters", "forward": true}, "context":  

        [  

            { "key": "following_text", "operator": "regex_contains", "operand": "^[)\\]\\>\\'\\\"\\ %>\\}\\;\\,]", "match_all": true },  

            { "key": "preceding_text", "operator": "not_regex_match", "operand": "^.*\\{$", "match_all": true  },  

            { "key": "auto_complete_visible", "operator": "equal", "operand": false }  

        ]  

    } ,

{

"keys":["alt+ctrl+z"],

"command":"side_bar_open_in_browser",

"args":{

"paths":[],

"type":"testing",

"browser":"chrome"

    }

},

//alt+k 向左移动光标（单字符）  alt+k 向右移动光标

//alt+h向左移动光标（单词）  alt+l 向右移动光标

{ "keys": ["alt+k"], "command": "move", "args": {"by": "characters", "forward": true} },

{ "keys": ["alt+j"], "command": "move", "args": {"by": "characters", "forward": false} },

{ "keys": ["alt+l"], "command": "move", "args": {"by": "word_ends", "forward": true} },

{ "keys": ["alt+h"], "command": "move", "args": {"by": "word_ends", "forward": false} },

//下一行 alt+enter

{ "keys": ["alt+enter"], "command": "move", "args": {"by": "lines", "forward": true} },

//上一行alt+space

{ "keys": ["alt+space"], "command": "move", "args": {"by": "lines", "forward": false} },

{ "keys": ["ctrl+alt+a"], "command": "alignment" }

]

推荐：博主历时三年倾注大量心血创作的《大数据平台架构与原型实现：数据中台建设实战》一书已由知名IT图书品牌电子工业出版社博文视点出版发行，真诚推荐给每一位读者！点击《重磅推荐：建大数据平台太难了！给我发个工程原型吧！》了解图书详情，扫码进入京东手机购书页面！

 
 
文章目录
推荐：博主历时三年倾注大量心血创作的[《大数据平台架构与原型实现：数据中台建设实战》](https://item.jd.com/12677623.html)一书已由知名IT图书品牌电子工业出版社博文视点出版发行，真诚推荐给每一位读者！点击[《重磅推荐：建大数据平台太难了！给我发个工程原型吧！》](https://laurence.blog.csdn.net/article/details/106851739)了解图书详情，扫码进入京东手机购书页面！
在调用一个单一参数函数时，如果参数本身是一个通过case语句实现的 “偏函数”，你只能使用“花括号”


尽管这是一个非常基础的问题，但是如果不仔细梳理一下，还是会导致在某些场景下误读代码。原因是Scala对这两兄弟的使用实在是太灵活了，甚至可以说有些“随便”，本文将况逐一讨论下两者在不同场景的使用方法和区别。本文原文出处: http://blog.csdn.net/bluishglc/article/details/52946575 严禁任何形式的转载，否则将委托CSDN官方维护权益！

#在调用函数时
人们会笼统地说在函数调用时，小括号和花括号是通用的，但实际上，情况会复杂的多
##如果你要调用的函数有两个或两个以上的参数，那么你只能使用“小括号”
请看下面的示例：
scala> var add = (x: Int,y: Int) => x + y
add: (Int, Int) => Int = <function2>

scala> add(1,2)
res0: Int = 3

scala> add{1,2}
<console>:1: error: ';' expected but ',' found.
add{1,2}
     ^

##如果你要调用的函数只有单一参数，那么“通常”情况下小括号和花括号是可以互换的
请看下面的示例：
scala> var increase = (x: Int) => x + 1
increase: Int => Int = <function1>

scala> increase(10)
res0: Int = 11

scala> increase{10}
res1: Int = 11

##在调用单一参数函数时，小括号和花括号虽然等效，但还是有差异的
如果使用小括号，意味着你告诉编译器：它只接受单一的一行，因此，如果你意外地输入2行或更多，编译器就会报错。但对花括号来说则不然，如果你在花括号里忘记了一个操作符，代码是可以编辑的，但是会得到出乎意料的结果，进而导致难以追踪的Bug. 看如下的例子：
scala> def method(x: Int) = {
     |     x + 1
     | }
method: (x: Int)Int

scala> method {
     |   1 +
     |   2
     |   3
     | }
<console>:14: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses
         1 +
           ^
res14: Int = 4

scala> method(
     |   1 +
     |   2
     |   3
<console>:4: error: ')' expected but integer literal found.
  3
  ^

花括号的调用虽然有warning，但是可以编译通过，小括号的调用会编译报错，但是花括号版本的返回值4是一个超出预期的结果。注意，16-19行，1+2是一行，它们合在一起才是一个完整的表达式，3是独立的表达式，算第二行。
所以，在调用单一参数函数时，特别是高阶函数， 如果函数参数用一行可以表达，通常我们推荐还是使用小括号，这样我们可以借助编译器获得更好的错误检查。
在调用一个单一参数函数时，如果参数本身是一个通过case语句实现的 “偏函数”，你只能使用“花括号”
究其原因，我觉得scala对小括号和花括号的使用还是有一种“习惯上”的定位的：通常人们还是会认为小括号是面向单行的，花括号面向多行的。在使用case实现偏函数时，通常都会是多个case语句，小括号不能满足这种场合，只是说在只有一个case语句时，会让人产生误解，认为只有一行，为什么不使用case语句。
scala> val tupleList = List[(String, String)]()
tupleList: List[(String, String)] = List()

scala> val filtered = tupleList.takeWhile( case (s1, s2) => s1 == s2 )
<console>:1: error: illegal start of simple expression
val filtered = tupleList.takeWhile( case (s1, s2) => s1 == s2 )
                                    ^

scala> val filtered = tupleList.takeWhile{ case (s1, s2) => s1 == s2 }
filtered: List[(String, String)] = List()

#作为表达式（expression）和语句块（code blocks）时
if you need declarations, multiple statements, an import or anything like that, you need curly braces. And because an expression is a statement, parenthesis may appear inside curly braces. But the interesting thing is that blocks of code are also expressions, so you can use them anywhere inside an expression:
在非函数调用时，小括号可以用于界定表达式，花括号可以用于界定代码块。代码块由多条语句(statement)组成，每一条语句可以是一个"import"语句，一个变量或函数的声明，或者是一个表达式（expression），而一个表达式必定也是一条语句（statement），所以小括号可能出现在花括号里面，同时，语句块里可以出现表达式，所以花括号也可能出现在小括号里。看看下面的例子：
1       // literal - 字面量
(1)     // expression - 表达式
{1}     // block of code - 代码块
({1})   // expression with a block of code - 表达式里是一个语句块
{(1)}   // block of code with an expression - 语句块里是一个表达式
({(1)}) // you get the drift... - 你懂的。。。。

VIM中括号和引号自动补全和删除


经过一整天的努力，vimrc总算可以正常的工作了（至少看起来是这样，如果发现问题，欢迎指正）。其他帖子基本上只是给出了自动补全括号的vimrc代码，而删除的却很少。这里分享一下我的自动补全的代码（主要参考其他网友给出的方法），其中包括一种括号删除的方法，在vim i模式下不影响BackSpace正常功能的前提下添加在删除几种常见的括号或引号时自动删除紧随其后的与之相匹配的反括号或引号的功能。

" 仅对指定文件格式设置自动补全功能
autocmd FileType c,cpp,sh,java,html,js,css,py exec AutoComplete()

func! AutoComplete()
    "相关映射
    :inoremap ( ()<Left>
    :inoremap ) <c-r>=ClosePair(')')<CR>
    :inoremap { {}<Left>
    :inoremap } <c-r>=ClosePair('}')<CR>
    :inoremap [ []<Left>
    :inoremap ] <c-r>=ClosePair(']')<CR>
    :inoremap " <c-r>=DQuote()<CR>
    :inoremap ' <c-r>=SQuote()<CR>
	" 将BackSpace键映射为RemovePairs函数
    :inoremap <BS> <c-r>=RemovePairs()<CR>
	" 将回车键映射为BracketIndent函数
	:inoremap <CR> <c-r>=BracketIndent()<CR>
endfunc

func! ClosePair(char)
    if getline('.')[col('.') - 1] == a:char
        return "\<Right>"
    else
        return a:char
    endif
endfunc

"自动补全双引号
func! DQuote()
    if getline('.')[col('.') - 1] == '"'
        return "\<Right>"
    else
		if getline('.')[col('.') - 2] == '"'
			return '"'
		else
			return "\"\"\<Left>"
    endif
endfunc
"自动补全单引号
func! SQuote()
    if getline('.')[col('.') - 1] == "'"
        return "\<Right>"
    else
		if getline('.')[col('.') - 2] == "'"
			return "'"
		else
	        return "''\<Left>"
    endif
endfunc

" 按BackSpace键时判断当前字符和前一字符是否为括号对或一对引号，如果是则两者均删除，并保留BackSpace正常功能
func! RemovePairs()
	let l:line = getline(".") " 取得当前行
	let l:current_char = l:line[col(".")-1] " 取得当前光标字符
	let l:previous_char = l:line[col(".")-2] " 取得光标前一个字符 

	if (l:previous_char == '"' || l:previous_char == "'") && l:previous_char == l:current_char
		return "\<delete>\<bs>"
	elseif index(["(", "[", "{"], l:previous_char) != -1
		" 将光标定位到前括号上并取得它的索引值
		execute "normal! h" 
		let l:front_col = col(".")
		" 将光标定位到后括号上并取得它的行和索引值
		execute "normal! %" 
		let l:line1 = getline(".")
		let l:back_col = col(".")
		" 将光标重新定位到前括号上
		execute "normal! %"
		" 当行相同且后括号的索引比前括号大1则匹配成功
		if l:line1 == l:line && l:back_col == l:front_col + 1
			return "\<right>\<delete>\<bs>"
		else
			return "\<right>\<bs>"
		end
	else
	  	return "\<bs>" 
	end
endfunc 

" 在大括号内换行时进行缩进
func! BracketIndent()
	let l:line = getline(".")
	let l:current_char = l:line[col(".")-1] 
	let l:previous_char = l:line[col(".")-2] 
	
	if l:previous_char == "{" && l:current_char == "}"
		return "\<cr>\<esc>\ko"
	else
		return "\<cr>"
	end
endfunc