FilesExpand file tree

 master

/

parse-names.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

196 lines (182 loc) · 6.25 KB

 master

/

parse-names.js

Copy path

Top

File metadata and controls

• Code
• Blame

196 lines (182 loc) · 6.25 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

// based on PHP Name Parser by Josh Fraser (joshfraser.com)

// http://www.onlineaspect.com/2009/08/17/splitting-names/

// ported to JavaScript by Mark Pemburn (pemburnia.com)

// released under Apache 2.0 license

Array.prototype.in_array = function (value) {

for (var i = 0; i < this.length; i++) {

if (this[i] == value) {

return true;

}

}

return false;

};

Array.prototype.implode = function (separator) {

var output = "";

var sep = "";

for (var i = 0; i < this.length; i++) {

output += sep + this[i];

sep = separator;

}

return output;

};

String.prototype.trim = function() {

return this.replace(/^\s+|\s+$|\,$/g,"");

};

String.prototype.ucfirst = function() {

return this.substr(0,1).toUpperCase() + this.substr(1,this.length - 1).toLowerCase();

};

function NameParse() {

var me = this;

// split full names into the following parts:

// - prefix / salutation (Mr., Mrs., etc)

// - given name / first name

// - middle initials

// - surname / last name

// - suffix (II, Phd, Jr, etc)

NameParse.prototype.parse = function (fullastName) {

fullastName = fullastName.trim();

// split into words

var unfilteredNameParts = fullastName.split(" ");

var name = {};

var nameParts = [];

var lastName = "";

var firstName = "";

var initials = "";

var j = 0;

var i = 0;

// completely ignore any words in parentheses

for (i=0; i<unfilteredNameParts.length; i++) {

if (unfilteredNameParts[i].indexOf("(") == -1) {

nameParts[j++] = unfilteredNameParts[i];

}

}

var numWords = nameParts.length;

// is the first word a title? (Mr. Mrs, etc)

var salutation = me.is_salutation(nameParts[0]);

var suffix = me.is_suffix(nameParts[nameParts.length - 1]);

// set the range for the middle part of the name (trim prefixes & suffixes)

var start = (salutation) ? 1 : 0;

var end = (suffix) ? numWords - 1 : numWords;

// concat the first name

for (i=start; i<(end - 1); i++) {

word = nameParts[i];

// move on to parsing the last name if we find an indicator of a compound last name (Von, Van, etc)

// we use i != start to allow for rare cases where an indicator is actually the first name (like "Von Fabella")

if (me.is_compound_lastName(word) && i != start) {

break;

}

// is it a middle initial or part of their first name?

// if we start off with an initial, we'll call it the first name

if (me.is_initial(word)) {

// is the initial the first word?

if (i == start) {

// if so, do a look-ahead to see if they go by their middle name

// for ex: "R. Jason Smith" => "Jason Smith" & "R." is stored as an initial

// but "R. J. Smith" => "R. Smith" and "J." is stored as an initial

if (me.is_initial(nameParts[i + 1])) {

firstName += " " + word.toUpperCase();

} else {

initials += " " + word.toUpperCase();

}

// otherwise, just go ahead and save the initial

} else {

initials += " " + word.toUpperCase();

}

} else {

firstName += " " + me.fix_case(word);

}

}

// check that we have more than 1 word in our string

if ((end - start) > 1) {

// concat the last name

for (j=i; j<end; j++) {

lastName += " " + me.fix_case(nameParts[j]);

}

} else {

// otherwise, single word strings are assumed to be first names

firstName = me.fix_case(nameParts[i]);

}

// return the various parts in an array

name.salutation = (salutation != false) ? salutation : "";

name.firstName = (firstName != "") ? firstName.trim() : "";

name.initials = (initials != "") ? initials.trim() : "";

name.lastName = (lastName != "") ? lastName.trim() : "";

name.suffix = (suffix != false) ? suffix : "";

return name;

};

// detect and format standard salutations

// I'm only considering english honorifics for now & not words like

this.is_salutation = function (word) {

// ignore periods

word = word.replace(".","").toLowerCase();

// returns normalized values

if (word == "mr" || word == "master" || word == "mister") {

return "Mr.";

} else if (word == "mrs") {

return "Mrs.";

} else if (word == "miss" || word == "ms") {

return "Ms.";

} else if (word == "dr") {

return "Dr.";

} else if (word == "rev") {

return "Rev.";

} else if (word == "fr") {

return "Fr.";

} else {

return false;

}

};

// detect and format common suffixes

this.is_suffix = function (word) {

// ignore periods

word = word.replace(/\./g,"").toLowerCase();

// these are some common suffixes - what am I missing?

var suffixArray = ['I','II','III','IV','V','Senior','Junior','Jr','Sr','PhD','APR','RPh','PE','MD','MA','DMD','CME'];

for (var i=0; i<suffixArray.length; i++) {

if (suffixArray[i].toLowerCase() == word) {

return suffixArray[i];

}

}

return false;

};

// detect compound last names like "Von Fange"

this.is_compound_lastName = function (word) {

word = word.toLowerCase();

// these are some common prefixes that identify a compound last names - what am I missing?

var words = ['vere','von','van','de','del','della','di','da','pietro','vanden','du','st.','st','la','lo','ter'];

return words.in_array(word);

};

// single letter, possibly followed by a period

this.is_initial = function (word) {

// ignore periods

word = word.replace(".","");

return (word.length == 1);

};

// detect mixed case words like "McDonald"

// returns false if the string is all one case

this.is_camel_case = function (word) {

var ucReg = /|[A-Z]+|s/;

var lcReg = /|[a-z]+|s/;

return (word.match(ucReg) != null && word.match(lcReg) != null);

};

// ucfirst words split by dashes or periods

// ucfirst all upper/lower strings, but leave camelcase words alone

this.fix_case = function (word) {

// uppercase words split by dashes, like "Kimura-Fay"

word = me.safe_ucfirst("-",word);

// uppercase words split by periods, like "J.P."

word = me.safe_ucfirst(".",word);

return word;

};

// helper this.for fix_case

this.safe_ucfirst = function (seperator, word) {

var words = [];

// uppercase words split by the seperator (ex. dashes or periods)

parts = word.split(seperator);

for (var i=0; i<parts.length; i++) {

var thisWord = parts[i];

words[i] = (me.is_camel_case(thisWord)) ? thisWord : thisWord.ucfirst.toLowerCase();

}

return words.implode(seperator);

};

}