js也是具有OOP（object oriented programming）特性的，OOP在构建一些大型应用程序还是有一套成熟理论的。作为C++的使用者在学习js中的OOP特性的过程中，能够较快地理解其中的各种术语和概念，也能比较两种语言的异同，深化知识理解。通过js的OOP特性的学习也让我开始从语言层面考虑程序设计问题。
本篇文章主要介绍了js中的一些OOP特性，并且比较了js与C++的语言特性。如果你能熟练掌握C++的OOP特性，本文能帮助你快速地对js中的OOP特性建立整体的认识。

• FCC javascript oop tutorial
  

近在FreeCodeCamp(FCC)学习前端的课程，其中有一节就是讲的 regexp ，也就是正则表达式。我之前零星地了解过一些正则表达式的相关知识，但不足以对正则表达式得出一个完整的认识。FCC的教程循序渐进，由简到繁，在教学中结合练习，非常适合初学者的学习过程。如何你的英文能够达到阅读技术类文献的水平，又正好想学习一下正则表达式，我推荐你试一下FCC的正则表达式教程，花3~4个小时就能够对正则表达式有个完整的理解。

教程使用的编程语言是javascript，需要注意的是不同语言之间的正则表达式在某些细节上还是略有区别的。

本篇文章主要是对学习过程中的知识点进行总结，方便以后进行查阅。

FCC的教程使用javascript作为开发语言，本节所有的代码都是js代码。

js中内置了正则表达式模块，下面是正则表达式在js中的使用示例

let myString = "Hello World";
let myRegex = /Hello/;
let result = myRegex.test(myString);

使用 | 进行or匹配

let regex2 = /cat|bird/;

使用 i 标识符在匹配时忽略大小写

let regex3 = /case/i;

使用正则表达式进行字符串过滤，使用 match 方法

let extractStr = "Extract the word 'coding' from this string.";
let codingRegex = /coding/; // Change this line
let result = extractStr.match(codingRegex); // Change this line

使用 g 进行返回满足规则的多次结果， g 为global的缩写

let twinkleStar = "Twinkle, twinkle, little star";
let starRegex = /twinkle/gi; // Change this line
let result = twinkleStar; // Change this line

使用 . 匹配所有的字符，使用 [] 匹配指定的字符

let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
let vowelRegex = /[aeiou]/gi; // Change this line
let result = quoteSample.match(vowelRegex); // Change this line

在 [] 中可以使用 - 代表一个范围

let quoteSample2 = "The quick brown fox jumps over the lazy dog.";
let alphabetRegex = /[a-z]/gi; // Change this line
let result = quoteSample2.match(alphabetRegex); // Change this line

这个范围还可以是多个，并且允许包含数字

let quoteSample3 = "Blueberry 3.141592653s are delicious.";
let myRegex = /[h-s2-6]/gi; // Change this line
let result = quoteSample3.match(myRegex); // Change this line

使用 ^ 符号能够匹配不包含某些字符

let quoteSample4 = "3 blind mice.";
let myRegex2 = /[^0-9aeiou]/gi; // Change this line
let  result = quoteSample4.match(myRegex2); // Change this line

使用 + 对出现连续出现的字符进行匹配

let difficultSpelling = "Mississippi";
let  myRegex3 = /s+/g; // Change this line
let result = difficultSpelling.match(myRegex3);

使用 * 星号匹配可能没有出现的次数（出现次数为 0~n 次）

let chewieQuote = "Aaaaaaaaaaaaaaaarrrgh!";
let chewieRegex = /Aa*/; // Change this line
let result = chewieQuote.match(chewieRegex);

使用 ? 进行较短匹配 （lazy match, 与greedy match 对应）

let text = "<h1>Winter is coming</h1>";
let myRegex = /<.*?>/; // Change this line
let result = text.match(myRegex);

使用 ^ 对出现在字符串开始位置进行匹配
注意上边也用到这个符号表示取反，是在 [] 中表示取反

let rickyAndCal = "Cal and Ricky both like racing.";
let calRegex = /^Cal/; // Change this line
let result = calRegex.test(rickyAndCal);

使用 $ 对出现在字符串结束位置进行匹配

let caboose = "The last car on a train is the caboose";
let lastRegex = /caboose$/; // Change this line
let result = lastRegex.test(caboose);

使用 \w 代替 [A-Za-z0-9_] ，包含所有的数字、字母和下划线

let quoteSample = "The five boxing wizards jump quickly.";
let alphabetRegexV2 = /\w/g; // Change this line
let result = quoteSample.match(alphabetRegexV2).length;

使用 \W 代替 [^A-Za-z0-9_] ，相当于上边的逆向匹配

let quoteSample = "The five boxing wizards jump quickly.";
let nonAlphabetRegex = /\W/g; // Change this line
let result = quoteSample.match(nonAlphabetRegex).length;

使用 \d 代替 [0-9] ，所有数字匹配

let numString = "Your sandwich will be $5.00";
let numRegex = /\d/g; // Change this line
let result = numString.match(numRegex).length;

使用 \D 代替 [^0-9] ，所有非数字匹配

let numString = "Your sandwich will be $5.00";
let noNumRegex = /\D/g; // Change this line
let result = numString.match(noNumRegex).length;

使用 \s 代替 [ \r\t\f\n\v] ，与空格和换行相关

let sample = "Whitespace is important in separating words";
let countWhiteSpace = /\s/g; // Change this line
let result = sample.match(countWhiteSpace);

使用 \S=，代替 =[^ \r\t\f\n\v] ，不包含空格和换行

let sample = "Whitespace is important in separating words";
let countNonWhiteSpace = /\S/g; // Change this line
let result = sample.match(countNonWhiteSpace);

使用 {min, max} 对字符出现的次数进行限定
回想起使用 + 限制次数为 {0,} ，使用 - 限制次数为 {1,}

let ohStr = "Ohhh no";
let ohRegex = /Oh{3,6} no/; // Change this line
let result = ohRegex.test(ohStr);

仅限制出现次数的下限 {min,}

let haStr = "Hazzzzah";
let haRegex = /Haz{4,}ah/; // Change this line
let result = haRegex.test(haStr);

指定出现的次数 {count}

let timStr = "Timmmmber";
let timRegex = /Tim{4}ber/; // Change this line
let result = timRegex.test(timStr);

使用 ? 匹配可能出现的字母
问号用于声明lazy match，如何判断是lazy match还是匹配可能出现的东西呢

let favWord = "favorite";
let favRegex = /favou?rite/; // Change this line
let result = favRegex.test(favWord);

lookahead 的概念， (?=...) 与 (?!...)

下面的正则表达式用于检查密码，由3~6个字母和至少1个数字组成

let password = "abc123";
let checkPass = /(?=\w{3,6})(?=\D*\d)/;
let result = checkPass.test(password); // Returns true

下面的正则表达式用于检查密码，有5个以上的字符和至少2个数字组成

let sampleWord = "astronaut";
let pwRegex = /(?=\w{5,})(?=\D*\d{2,})/; // Change this line
let result = pwRegex.test(sampleWord);

截取字符串中的重复部分，使用括号 () 对内容进行补充，是用 \1 表示第一个捕捉到的字符

let repeatNum = "42 42 42";
let reRegex = /^(\d*)\s\1\s\1$/; // Change this line
let result = reRegex.test(repeatNum);

通过截取字符串，可以对截取的字符串进行修改或替换操作，需要使用 replace 方法

"Code Camp".replace(/(\w+)\s(\w+)/, '$2 $1'); // Returns "Camp Code"

下面的正则表达式就是用于将 good 替换为 okey-dokey

let huhText = "This sandwich is good.";
let fixRegex = /good/; // Change this line
let replaceText = "okey-dokey"; // Change this line
let result = huhText.replace(fixRegex, replaceText);

使用正则表达式实现类似 .trim() 的功能

let hello = "   Hello, World!  ";
let wsRegex = /^\s+|\s+$/g; // Change this line
let result = hello.replace(wsRegex, ''); // Change this line

在emacs中内置了 string-match 函数进行正则表达式匹配，其函数原型为 (string-match REGEXP STRING &optional START) ，下面就是在emacs中使用regexp的示例。

(setq str-regexp "\.[h|cpp]$")
(setq str-sample-1 "sample1.h")
(string-match str-regexp str-sample-1)

python中内置了 re 模块用于正则表达式匹配，下面就是在python中的regexp示例。

import re
pattern = r"Cookie"
sequence = "Cookie"
if re.match(pattern, sequence):
    print("Match!")
else:
    print("Not a match!")

• FCC regular-expression tutorial
  
• emacs string-match manual
  
• python re module
  

Implement atoi which converts a string to an integer.

The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.

The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.

If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.

If no valid conversion could be performed, a zero value is returned.

Note:
Only the space character ' ' is considered as whitespace character.
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2³¹, 2³¹ − 1]. If the numerical value is out of the range of representable values, INT_MAX (2³¹ − 1) or INT_MIN (−2³¹) is returned.

Example 1:
Input: "42"
Output: 42

Example 2:
Input: " -42"
Output: -42
Explanation: The first non-whitespace character is '-', which is the minus sign.
Then take as many numerical digits as possible, which gets 42.

Example 3:
Input: "4193 with words"
Output: 4193
Explanation: Conversion stops at digit '3' as the next character is not a numerical digit.

Example 4:
Input: "words and 987"
Output: 0
Explanation: The first non-whitespace character is 'w', which is not a numerical
digit or a +/- sign. Therefore no valid conversion could be performed.

Example 5:
Input: "-91283472332"
Output: -2147483648
Explanation: The number "-91283472332" is out of the range of a 32-bit signed integer.
Thefore INT_MIN (−2³¹) is returned.

来源 leetcode 8 string to integer

• stackoverflow.com sync with stdio
  

对于mapreduce的兴趣起源于我最近在学习javascript时遇到了map和reduce函数。使用这两个函数进行数据处理时，总感觉思路有一点奇特，理解起来需要绕一个弯子。之前在学python时，也看到过这两个函数，但是当时没有在意，现在我觉得我有必要对这两个函数做一个深入的研究了。

MapReduce的深层概念远比两个函数来得复杂，它是一个编程模型，主要用于解决大数据处理问题。使用这种模式编写的程序是可并行的（parallelized）并适用于大型计算机集群。运行时由系统自动对输入数据进行分割、协调多机器间的计算任务、进行异常处理、管理机器间的内部通信。这样，没有并行计算和分布式系统相关经验的开发人员也能够借助大型分布式系统进行数据处理了。

百度百科中给出的定义比较全面，而且很准确。

MapReduce是面向大数据并行处理的计算模型、框架和平台，它隐含了以下三层含义：
1）MapReduce是一个基于集群的高性能并行计算平台（Cluster Infrastructure）。它允许用市场上普通的商用服务器构成一个包含数十、数百至数千个节点的分布和并行计算集群。
2）MapReduce是一个并行计算与运行软件框架（Software Framework）。它提供了一个庞大但设计精良的并行计算软件框架，能自动完成计算任务的并行化处理，自动划分计算数据和计算任务，在集群节点上自动分配和执行任务以及收集计算结果，将数据分布存储、数据通信、容错处理等并行计算涉及到的很多系统底层的复杂细节交由系统负责处理，大大减少了软件开发人员的负担。
3）MapReduce是一个并行程序设计模型与方法（Programming Model & Methodology）。它借助于函数式程序设计语言Lisp的设计思想，提供了一种简便的并行程序设计方法，用Map和Reduce两个函数编程实现基本的并行计算任务，提供了抽象的操作和并行编程接口，以简单方便地完成大规模数据的编程和计算处理。

从编程语言的角度上来说
map操作会接收到两个参数，一个列表和一个变换过程，其功能是将这个变换过程映射到每一个列表成员上，从而得到一个新的列表。
reduce操作也会接收到两个参数，一个列表和一个变换过程，其功能是将这个变换过程从前向后作用在列表成员上，最终得到一个列表中条目。

从分布式系统的角度上来说 (以下内容摘自百度百科)

简单说来，一个映射函数就是对一些独立元素组成的概念上的列表（例如，一个测试成绩的列表）的每一个元素进行指定的操作（比如前面的例子里，有人发现所有学生的成绩都被高估了一分，它可以定义一个“减一”的映射函数，用来修正这个错误。）。事实上，每个元素都是被独立操作的，而原始列表没有被更改，因为这里创建了一个新的列表来保存新的答案。这就是说，Map操作是可以高度并行的，这对高性能要求的应用以及并行计算领域的需求非常有用。
而化简操作指的是对一个列表的元素进行适当的合并（继续看前面的例子，如果有人想知道班级的平均分该怎么做？它可以定义一个化简函数，通过让列表中的元素跟自己的相邻的元素相加的方式把列表减半，如此递归运算直到列表只剩下一个元素，然后用这个元素除以人数，就得到了平均分。）。虽然他不如映射函数那么并行，但是因为化简总是有一个简单的答案，大规模的运算相对独立，所以化简函数在高度并行环境下也很有用。

我之前在学习语言层面的map和reduce时，很难理解其用途，结合分布式计算的背景知识，就能够较形象地理解map和reduce操作的过程和作用。

mapreduce模型给并行计算带来了革命性的影响，它是目前为止最成功、最广为接受和最易于使用的大数据并行处理技术。

mapreduce最初由google提出，并开发出了如下产品

• Google File System（大规模分散文件系统）
  
• MapReduce （大规模分散FrameWork）
  
• BigTable（大规模分散数据库）
  
• Chubby（分散锁服务）
  

随后就有其对应的开源实现，也就是Hadoop。Hadoop是Apache软件基金会发起的一个项目，它是一种分布式数据和计算的框架，它包含许如下子项目。

• HDFS，hadoop distributed file system，是Google File System的开源实现
  
• MapReduce，是Google MapReduce的开源实现
  
• HBASE，类似Google BigTable的分布式NoSQL数据库
  
• Zookeeper，分布式锁服务，类似Google Chubby
  

• google mapreduce paper
  
• 百度百科 mapreduce
  
• Hadoop主页
  

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

P   A   H   N
A P L S I I G
Y   I   R

And then read line by line: "PAHNAPLSIIGYIR"
Write the code that will take a string and make this conversion given a number of rows:
string convert(string s, int numRows);

Example 1:
Input: s = "PAYPALISHIRING", numRows = 3
Output: "PAHNAPLSIIGYIR"

Example 2:
Input: s = "PAYPALISHIRING", numRows = 4
Output: "PINALSIGYAHRPI"
Explanation:

P     I    N
A   L S  I G
Y A   H R
P     I

来源： LeetCode 06 ZigZag Conversion

本文主要对css flexbox的关键点了总结，方便以后在以后的查阅。

对于容器需要指定其显示方式为flexbox

display: flex;

指定flex排列的方向、在排列时是否会换行，使用 flex-flow 可以快速设置二者属性

flex-direction: row | row-reverse | column | column-reverse;
flex-wrap: nowrap | wrap | wrap-reverse;
flex-flow: <'flex-direction'> || <'flex-wrap'>;

用于调整主轴方向的排布（对于 row 来说就是横向，对于 column 来说就是纵向）

justify-content: flex-start | flex-end | center
	       | space-between | space-around | space-evenly;

用于调整相交轴方向的行间排布（对于 row 来说就是纵向，对于 column 来说就是横向）

align-content: flex-start | flex-end | center
	     | stretch | space-between | space-around;

用于调整相交交轴方向的单行对齐方式。需要注意的是其中 center 和 baseline 的区别： 二者都表示居中，而 baseline 会保证所有文字的底边处在同一条线上。

align-items: flex-start | flex-end | center | baseline | stretch;

用于调整顺序

order: <integer>; /* default 0 */

用于调整每个条目的伸展程度

flex-grow: <number>; /* default 0 */

用于调整每个条目的缩小程度

flex-shrink: <number>; /* default 1 */

用于调整每个条目的默认尺寸

flex-basis: <length> | auto; /* default auto */

设置flex属性，排列顺序为 flex-grow , flex-shrink , flex-basis

flex: none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ];

用于重载容器的 align-items 的设置

align-self: auto | flex-start | flex-end | center | baseline | stretch;

• css-tricks.com
  
• w3.org css-flexbox
  

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example 1:
Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example 2:
Input: "cbbd"
Output: "bb"

来源：LeetCode 05 Longest Palindromic Substring

我想到了两种方法：暴力解法、从中心展开

Given a string, find the length of the longest substring without repeating characters.

Examples:
Given "abcabcbb", the answer is "abc", which the length is 3.
Given "bbbbb", the answer is "b", with the length of 1.
Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

来源：LeetCode 03 Longest Substring Without Repeating Characters

好久没刷算法题了，手有点生，没有什么思路，下面的答案是看过提示之后才写出来的。

Gaurab Paul的 一篇博文 给了我很大的启发，他详细地介绍了emacs中的相关概念，并提供了许多充满想象力的小技巧。作为emacs的入门级选手确实学到了很多，也拓宽了自己的思路。

我最初的开发环境是Visual Studio，这一类比较大型的IDE集成了许多功能，但同时也会束缚住使用者的想法。通过这篇文章我感受到的由普通操作指令能组合成的新编辑方式。

如果英文水平允许的话，非常推荐阅读一下原版的博文，原文中有更加丰富形象的图片示例，无论是跟我一样刚刚入门emacs的新手，还是经验丰富的老兵，都能够从中获得启发。下面，我结合自己的理解和收获谈谈emacs中操作的体会。

我之前进行代码段复制的操作是十分基础的，用 C-@ 模拟鼠标按下，方向键模拟鼠标拖动，在鼠标拖动的过程中就形成了一个选区，然后用 M-w 对这个选区进行复制操作，用 C-y 粘贴被复制的内容。

以上操作带出了几个非常重要的概念 。在emacs中，鼠标光标所在位置被称作 point ；组合键 C-@ 执行的是 set-mark-command 命令，就是将 point 所在位置标记为 mark ；通过移动光标，也就是移动 point 后，在 point 与 mark 之间就形成了 region 。

有些插件拓展能够实现光标的快速定位，如 helm-swoop 和 avy 。

• lorefnon.tech
  
• helm-swoop
  
• avy
  

在linux中借助shell等命令行工具能够很方便地与操作系统交互，可以在shell中将命令或程序的输入结果重定向到特定地方，很方便地实现一些功能。这个技巧十分实用，使用输出重定向能够极大地简化我们的日常操作。

示例如下，运行下面的命令能够把 ls 命令的运行结果写入到 ls-output.txt 中。使用 > 会把程序运行时本该输出到 stdout 的内容重定向到指定名称的文件中。

ls . > ls-output.txt

可以在 > 左面写上数字和 & ，用以标识在重定向时的特殊用法。下面会给出一些特殊用法的实例。

使用管道符号 | 能够将一个程序的输出重定向到另一个程序的输入中去。下面的命令会将 ls 的输出（ stdout ）重定向到 grep 的输入（ stdin ）中去。管道命令在linux中是最常见的用法。

ls | grep <pattern>

由于在工作中需要开发一套内存缓存服务，使用了共享内存作为多进程间的数据共享。为了提高共享内存缓存服务的性能，我找了一个类似的较为成熟的开源项目 libshmcache ，通过研究源码学习其中的优点并改进自己的模块。

libshmcache与redis相似的是都使用内存进行数据缓存；与redis不同的是，redis使用的进程自己申请的动态内存，而libshmcache使用的是共享内存。使用共享内存就意味着libshmcache主要的应用场景是同一台主机上的数据缓存。

我花了一周时间阅读了比较感兴趣的部分代码，收获不少，现就以下几个方面总结一下自己的心得：

• 纯C语言开发的代码风格
  
• hash table的原理和实现
  
• gcc原子化操作接口
  
• 有锁写和无锁读的实现细节
  
• 共享内存的两套函数接口(POSIX和SystemV)
  

我在工作中使用比较多的开发语言是C++，对于C语言编写的这样规模的项目，还是第一次仔细深入地研究。C语言使用 struct 作为大多数自定义数据结构的关键字，相对于C++能够使用成员函数能够对类进行功能拓展，C语言比较常用的是将这个对象作为输入参数传到函数中。

纵观所有项目代码，我感受比较深的就是使用结构体中嵌套匿名结构体，这样做能够增强数据结构的层次感，示例代码如下：

struct shmcache_context {
    pid_t pid;
    int lock_fd;    //for file lock
    int detect_deadlock_clocks;
    struct shmcache_config config;
    struct shm_memory_info *memory;
    struct {
	struct shmcache_segment_info hashtable;
	struct {
	    int count;
	    struct shmcache_segment_info *items;
	} values;
    } segments;

    struct shmcache_value_allocator_context value_allocator;
    struct shmcache_list list;   //for value recycle
    bool create_segment;  //if check segment size                                  
};

注意 shmcache_context 中的匿名结构体 segments 和 values ，这样的写法体现了相互包含关系，也使后续的操作该数据结构的语句更加容易理解。

另外对于联合体和位域这两种技术也是我在之前开发中使用比较少的，通过阅读源码能够让我对其有了更深刻的理解。示例代码如下：

union shm_hentry_offset {
    int64_t offset;
    struct {
	int index :16;
	int64_t offset :48;
    } segment;
};

这段代码使用了联合体赋予了 shm_hentry_offset 两种访问方式，又使用了位域将 int64_t 分割为两段。

libshmcache内部使用的是hash table做内部缓存的数据结构，这使查找的时间复杂度是O(1)。
之前看过一些介绍hash table的资料，对hash table的工作原理是有过一个基础的了解的，这次通过阅读源码，能够了解到hash table在代码实现上更加细节的内容。
对于hash计算中出现的hash值冲突，即在hash计算时出现了两个不同的key在经过hash计算后得到的bucket相同，libshmcache采用的解决方案是使用linked list来存放这些相同bucket对应的value。

使用原子化操作接口能够解决一些并发读写问题，原子化操作相对于互斥锁执行更快。原子化操作也是一种无锁编程的方式。

在libshmcache中，写操作通过 pthread_mutex_t 进行同步，而读操作是无锁的。
对于写操作来说，需要对hash table进行操作，这肯定是需要同步的。
将 pthread_mutex_t 保存在共享内存中，不同的进程通过映射共享内存就能获得同一个互斥量，通过这个互斥量就能完成进程间同步。

在linux上使用共享内存时有两套接口 mmap 和 shmget 。 mmap 是 POSIX 标准的接口，而 shmget 是 System V 标准的接口，两者都能够实现进程间共享内存，但他们在使用上还是有些区别的。对于 mmap 来说，需要在硬盘上创建一个文件，再将该文件映射到内存中。对于 shmget 来说，需要指定一个key，不同的进程通过相同的key就能映射到同一片内存。