I have this constructor:
var Song = function(side, name, index, duration, author, lyrics) {
this.side = side;
this.name = name;
this.index = index;
this.duration = duration;
this.author = author;
this.lyrics = lyrics;
globalLyrics.push(this);
};
Then I created instances of songs:
var song1 = new Song('Mithras', 'Wicked', 1, '3:45', 'Me and The Plant',
["politicians", "politician", "politics", "telling",
"lies", "lie", "to", "media", "the", "youngsters",
"young", "elders", "time", "that", "passes", "pass", "by",
"oh", "no", "lie", "detector", "detection", "souls", "as",
"far", "illusion", "goes", "all", "sinners", "sin", "around",
"sun", "earth", "atom", "atoms", "mind", "angels", "angel",
"prophet", "prophets", "martyr", "knives", "elder", "detect",
"shit", "flies", "fly", "meat", "is", "knife", "and", "death",
"life", "I", "am", "gonna", "going", "cast", "a", "sacred",
"circle"]);
var song2 = new Song('Mithras', 'Requiem', 11, '3:25', 'Me and The Plant',
["you", "want", "wanna", "get", "some", "and", "what",
"is", "a", "sad", "song", "move", "along", "then", "trip",
"on", "are", "try", "trying", "to", "belong", "oh", "no", "it",
"the", "go", "up", "like", "king", "kong", "come", "coming",
"down", "goes", "minor", "key", "unlock", "unlocks",
"moans", "moan", "all", "integrity", "just", "breaks", "bones",
"I", "wait", "for", "in", "line", "that", "will", "bring", "me",
"home", "wrong", "feels", "feel", "right", "wretchedness",
"wretch", "among", "amongst", "so", "warm", "never", "be",
"alone", "because", "cause", "have", "these", "life", "short",
"break", "politicians"]);
Later I added a method to the prototype:
Song.prototype.playLyrics = function() {
for(var i = 0; i < this.lyrics.length; i++){
console.log (this.lyrics[i]);
}
};
Lets say I have a user input (later on a form):
var input = ["politicians"];
And an intersection function:
function intersection (input, lyrics){
return input.filter(function(n){
return lyrics.indexOf(n) != -1
});
}
QUESTION:
Since intersection() is not part of the Song prototype, how do I make a function to return the NAME of the song -this.name relative to the lyrics this.lyrics that has the most intersections with the user input?
In short, given the above example, I want to enter var input = ["politician"] and return //Wicked
I think that you are trying to make the function to search song's name by lyrics ?
1. Using song as argument
function intersection(input, song ){
}
2.You can store all the songs by global variable like
var songList = [];
// Push the song on the list when you make the song
var song1 = new Song(...);
songsList.push(song1);
// Using songsList to make your search
function intersection(input){
// Find the name of song by loop the songList
}
Having a little issue with some logic and underscore.js.
I have the following array of common words:
var common_words = ["a", "an", "the", "all", "am", "an", "and", "any", "are", "as", "at", "be", "but", "can", "did", "do", "does", "for", "from", "had", "has", "have", "here", "how", "i", "if","in", "is", "it", "no", "not", "of", "on", "or", "so", "that", "the", "then", "there", "this", "to", "too", "up", "use", "what", "when", "where", "who", "why", "you"];
and I have the following string being passed in:
this is the printer that has the words on it
now what should happen is that all the common words should get stripped out simply leaving the words "printer" and "words".
I have tried using underscore.js as below but it is not working as expected and simply returning everything that matches the common_words array.
$('.tagTrigger').blur(function () {
var subjectVal = $('#txtSubject').val().split(/ +/);
$.each(subjectVal, function (index, itm) {
console.log(itm);
console.log(_.reject(common_words, function (item) { return item != itm }));
});
});
Any help with this would be greatly appreciated, just need another pair of eyes I guess :-)
now what should happen is that all the common words should get
stripped out simply leaving the words "printer" and "words".
I don't think you need underscorejs here. The following would suffice.
var subjectVal = "this is the printer that has the words on it";
subjectVal = subjectVal.replace(new RegExp("\\b(" + common_words.join("|") + ")\\b", "g"), "");
The above would leave the words but with spaces, which can be easily removed like
var result = subjectVal.replace(/\s+/g," ").trim();
You don't really need Underscore. You can use pure Javascript by splitting your sentence and filtering it with Array.prototype.filter
"this is the printer that has the words on it".split(" ").filter(function(word){
return common_words.indexOf(word) === -1;
}).join(' ');
results
"printer words"
A bit late to the party, but here's a version using underscore:
var commonWord = function(word){
return _.contains(common_words, word);
}
var text = "this is the printer that has the words on it";
var words = text.split(' ');
var uncommonWords = _.reject(words, commonWord);
var common_words = ["a", "an", "the", "all", "am", "an", "and", "any", "are", "as", "at", "be", "but", "can", "did", "do", "does", "for", "from", "had", "has", "have", "here", "how", "i", "if","in", "is", "it", "no", "not", "of", "on", "or", "so", "that", "the", "then", "there", "this", "to", "too", "up", "use", "what", "when", "where", "who", "why", "you"];
var commonWord = function(word){
return _.contains(common_words, word);
}
var text = "this is the printer that has the words on it";
var words = text.split(' ');
var uncommonWords = _.reject(words, commonWord);
document.getElementById("uncommonText").innerHTML = uncommonWords.join(' ')
<script src="http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.7.0/underscore-min.js"></script>
<p id='uncommonText'></p>
I would like a regex that can remove the domain extension from a string e.g. The string is from a text field so the user may or may not include http://www.
var fqdn = "http://www.mydomainname.com";
var name = regex_function(fqdn);
// name === "mydomainname"
There are 2 main ways to do this: with regular expressions and with using the DOM.
function regex_function(fqdn) {
var a = document.createElement('a');
a.href = fqdn;
return a.hostname || undefined;
}
There's no reliable way to remove domain extensions like .com, but why would you do that anyway?
This function does remove a few extensions, but please DO NOT use this, I just added it here to show you how much work and unnecessary code is required to even get close to removing a small portion of these extensions:
function removeExt(str){
var a = document.createElement('a');
a.href = str;
var hostName = a.hostname;
var domainExtensions = [
"gov", "org", "co", "com", "in", "info", "net", "uk", "af", "am", "ar", "au", "as", "az", "be", "bg", "bn", "bo", "bs", "ca", "cs", "cy", "da", "de", "dv", "el", "en", "es", "et", "eu", "fa", "fi", "fo", "fr", "gd", "gl", "gn", "gu", "he", "hi", "hr", "hu", "hy", "id", "is", "it", "jp", "ka", "kk", "km", "kn", "ko", "ks", "la", "lo", "lt", "lv", "mi", "mk", "ml", "mn", "mr", "ms", "mt", "my", "nb", "ne", "nl", "or", "pa", "pl", "pt", "rm", "ro", "ru", "sa", "sb", "sd", "si", "sk", "sl", "so", "sq", "sr", "sv", "sw", "ta", "te", "tg", "th", "tk", "tn", "tr", "ts", "tt", "uk", "ur", "uz", "vi", "xh", "yi", "zh", "zu"
];
var regex = new RegExp("\.?(\."+domainExtensions.join('|')+")+$");
return hostName.replace(regex,'');
}
Not so elegant, but it is working, in most regular cases- it seems:
function strip(fqdn) {
fqdn=fqdn.replace(/http:\/\/www./,'');
var i = fqdn.lastIndexOf('.');
var n=fqdn.substr(i,fqdn.length-1);
fqdn=fqdn.replace(n,'');
dot=fqdn.lastIndexOf('.');
if(dot!=-1) {
var n2=fqdn.substr(dot,fqdn.length-1);
fqdn=fqdn.replace(n2,'');
}
return fqdn;
}
Better one:
function strip_dom(fqdn) {
pattern=/\.+[0-9A-Za-z]+\./;
fqdn=fqdn.match(pattern);
fqdn=fqdn.join(fqdn,'');
fqdn=fqdn.replace(/\./g,'');
return fqdn;
}
Not working for subdomains (separated by dot), but with few tweaks...
When I add an extra 3 columns to the table my list items do not fill them. Instead it says undefined in the cells. If anyone can I ideally need a 6x6 table for my list items. Cheers.
var listOfWords = ["mat", "cat", "dog", "pit", "pot", "fog", "log", "pan", "can", "man", "pin", "gag", "sat", "pat", "tap", "sap", "tag", "gig", "gap", "nag", "sag", "gas", "pig", "dig", "got", "not", "top", "pop", "god", "mog", "cot", "cop", "cap", "cod", "kid", "kit", "get", "pet", "ten", "net", "pen", "peg", "met", "men", "mum", "run", "mug", "cup", "sun", "mud", "rim", "ram", "rat", "rip", "rag", "rug", "rot", "dad", "sad", "dim", "dip", "did", "mam", "map", "nip", "tin", "tan", "nap", "sit", "tip", "pip", "sip", "had", "him", "his", "hot", "hut", "hop", "hum", "hit", "hat", "has", "hug", "but", "big", "bet", "bad", "bad", "bed", "bud", "beg", "bug", "bun", "bus", "bat", "bit", "fit", "fin", "fun", "fig", "fan", "fat", "lap", "lot", "let", "leg", "lit" ];
var shuffledWords = listOfWords.slice(0, 6);
shuffledWords.sort(function () {
return 0.5 - Math.random();
});
var tbl = document.createElement('table');
tbl.className='tablestyle';
for (var i = 0; i < shuffledWords.length; i++) {
var word = shuffledWords[i];
var row = document.createElement('tr');
//Here is where I add the extra 3 columns
for (var j = 0; j < word.length + 3; j++){
var cell = document.createElement('td');
cell.textContent = word[j];
// IF FIREFOX USE cell.textContent = word[j]; INSTEAD
row.appendChild(cell);
}
tbl.appendChild(row);
}
document.body.appendChild(tbl);
If you are trying to display two words per line, you can do this:
var listOfWords = ["mat", "cat", "dog", "pit", "pot", "fog", "log", "pan", "can", "man", "pin", "gag", "sat", "pat", "tap", "sap", "tag", "gig", "gap", "nag", "sag", "gas", "pig", "dig", "got", "not", "top", "pop", "god", "mog", "cot", "cop", "cap", "cod", "kid", "kit", "get", "pet", "ten", "net", "pen", "peg", "met", "men", "mum", "run", "mug", "cup", "sun", "mud", "rim", "ram", "rat", "rip", "rag", "rug", "rot", "dad", "sad", "dim", "dip", "did", "mam", "map", "nip", "tin", "tan", "nap", "sit", "tip", "pip", "sip", "had", "him", "his", "hot", "hut", "hop", "hum", "hit", "hat", "has", "hug", "but", "big", "bet", "bad", "bad", "bed", "bud", "beg", "bug", "bun", "bus", "bat", "bit", "fit", "fin", "fun", "fig", "fan", "fat", "lap", "lot", "let", "leg", "lit" ];
var shuffledWords = listOfWords.slice(0).sort(function () {
return 0.5 - Math.random();
}).slice(0, 12);
var tbl = document.createElement('table');
tbl.className='tablestyle';
var wordsPerRow = 2;
for (var i = 0; i < shuffledWords.length; i += wordsPerRow) {
var row = document.createElement('tr');
for (var j=i; j < i + wordsPerRow; ++ j) {
var word = shuffledWords[j];
for (var k = 0; k < word.length; k++){
var cell = document.createElement('td');
cell.textContent = word[k];
// IF FIREFOX USE cell.textContent = word[j]; INSTEAD
row.appendChild(cell);
}
}
tbl.appendChild(row);
}
document.body.appendChild(tbl);
Added a demonstration of this: http://jsfiddle.net/Ks2Nk/
Not sure if you trying to randomise the letters in the 6x6 row
If not try
cell.textContent = word[j%3];
But this will simply repeat the word
So for example for mat
you'll have
m a t m a t
I want to get domain name only using javascript. Ex
vn.search.yahoo.com -> yahoo
vn.search.yahoo.com.vn -> yahoo
sub1.sub2.sub3.abcdef.co.uk -> abcdef
Thank you!
Edit: "domain" = domain without extension (ex: .com, .net, .co.uk...) and without sub domain (ex: www, email, cdn, support...)
Use location.host and cut off subdomains and the TLD:
var domain = (location.host.match(/([^.]+)\.\w{2,3}(?:\.\w{2})?$/) || [])[1]
update: as #demix pointed out, this fails for 2 and 3-letter domains. It also won't work for domains like aero, jobs and dozens others.
The only way around is to know valid TLDs in advance, so here is a more appropriate function:
// http://data.iana.org/TLD/tlds-alpha-by-domain.txt
var TLDs = ["ac", "ad", "ae", "aero", "af", "ag", "ai", "al", "am", "an", "ao", "aq", "ar", "arpa", "as", "asia", "at", "au", "aw", "ax", "az", "ba", "bb", "bd", "be", "bf", "bg", "bh", "bi", "biz", "bj", "bm", "bn", "bo", "br", "bs", "bt", "bv", "bw", "by", "bz", "ca", "cat", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl", "cm", "cn", "co", "com", "coop", "cr", "cu", "cv", "cx", "cy", "cz", "de", "dj", "dk", "dm", "do", "dz", "ec", "edu", "ee", "eg", "er", "es", "et", "eu", "fi", "fj", "fk", "fm", "fo", "fr", "ga", "gb", "gd", "ge", "gf", "gg", "gh", "gi", "gl", "gm", "gn", "gov", "gp", "gq", "gr", "gs", "gt", "gu", "gw", "gy", "hk", "hm", "hn", "hr", "ht", "hu", "id", "ie", "il", "im", "in", "info", "int", "io", "iq", "ir", "is", "it", "je", "jm", "jo", "jobs", "jp", "ke", "kg", "kh", "ki", "km", "kn", "kp", "kr", "kw", "ky", "kz", "la", "lb", "lc", "li", "lk", "lr", "ls", "lt", "lu", "lv", "ly", "ma", "mc", "md", "me", "mg", "mh", "mil", "mk", "ml", "mm", "mn", "mo", "mobi", "mp", "mq", "mr", "ms", "mt", "mu", "museum", "mv", "mw", "mx", "my", "mz", "na", "name", "nc", "ne", "net", "nf", "ng", "ni", "nl", "no", "np", "nr", "nu", "nz", "om", "org", "pa", "pe", "pf", "pg", "ph", "pk", "pl", "pm", "pn", "pr", "pro", "ps", "pt", "pw", "py", "qa", "re", "ro", "rs", "ru", "rw", "sa", "sb", "sc", "sd", "se", "sg", "sh", "si", "sj", "sk", "sl", "sm", "sn", "so", "sr", "st", "su", "sv", "sy", "sz", "tc", "td", "tel", "tf", "tg", "th", "tj", "tk", "tl", "tm", "tn", "to", "tp", "tr", "travel", "tt", "tv", "tw", "tz", "ua", "ug", "uk", "us", "uy", "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu", "wf", "ws", "xn--0zwm56d", "xn--11b5bs3a9aj6g", "xn--3e0b707e", "xn--45brj9c", "xn--80akhbyknj4f", "xn--90a3ac", "xn--9t4b11yi5a", "xn--clchc0ea0b2g2a9gcd", "xn--deba0ad", "xn--fiqs8s", "xn--fiqz9s", "xn--fpcrj9c3d", "xn--fzc2c9e2c", "xn--g6w251d", "xn--gecrj9c", "xn--h2brj9c", "xn--hgbk6aj7f53bba", "xn--hlcj6aya9esc7a", "xn--j6w193g", "xn--jxalpdlp", "xn--kgbechtv", "xn--kprw13d", "xn--kpry57d", "xn--lgbbat1ad8j", "xn--mgbaam7a8h", "xn--mgbayh7gpa", "xn--mgbbh1a71e", "xn--mgbc0a9azcg", "xn--mgberp4a5d4ar", "xn--o3cw4h", "xn--ogbpf8fl", "xn--p1ai", "xn--pgbs0dh", "xn--s9brj9c", "xn--wgbh1c", "xn--wgbl6a", "xn--xkc2al3hye2a", "xn--xkc2dl3a5ee0h", "xn--yfro4i67o", "xn--ygbi2ammx", "xn--zckzah", "xxx", "ye", "yt", "za", "zm", "zw"].join()
function getDomain(url){
var parts = url.split('.');
if (parts[0] === 'www' && parts[1] !== 'com'){
parts.shift()
}
var ln = parts.length
, i = ln
, minLength = parts[parts.length-1].length
, part
// iterate backwards
while(part = parts[--i]){
// stop when we find a non-TLD part
if (i === 0 // 'asia.com' (last remaining must be the SLD)
|| i < ln-2 // TLDs only span 2 levels
|| part.length < minLength // 'www.cn.com' (valid TLD as second-level domain)
|| TLDs.indexOf(part) < 0 // officialy not a TLD
){
return part
}
}
}
getDomain(location.host)
I hope I didn't miss too many corner cases. This should be available in the location object :(
Test cases: http://jsfiddle.net/hqBKd/4/
A list of TLDs can be found here: http://mxr.mozilla.org/mozilla-central/source/netwerk/dns/effective_tld_names.dat?raw=1
I was looking for something that would work for the majority of cases, without having to maintain the TLD list (and skip it's size!). It seems to me that you can do this pretty accurately by looking instead at the Second-Level Domain for common ones:
function getDomainName(domain) {
var parts = domain.split('.').reverse();
var cnt = parts.length;
if (cnt >= 3) {
// see if the second level domain is a common SLD.
if (parts[1].match(/^(com|edu|gov|net|mil|org|nom|co|name|info|biz)$/i)) {
return parts[2] + '.' + parts[1] + '.' + parts[0];
}
}
return parts[1]+'.'+parts[0];
}
Fiddle & Tests # http://jsfiddle.net/mZPaf/2/
Critiques/thoughts welcome.
var docdomain = document.domain.split('.');
var dom1 = "";
if (typeof (docdomain[docdomain.length - 2]) != 'undefined') dom1 = docdomain[docdomain.length - 2] + '.';
var domain = dom1 + docdomain[docdomain.length - 1];
console.log(domain);
//without subdomains
The only way I can imagine is list all the TLD. Sample code like below.
function getDomainName(){
var domainList = ['com','org','net',...];//all TLD
var tokens = document.domain.split('.');
while(tokens.length){
var token = tokens.pop();
if( domainList.indexOf(token) == -1 ){
return token;
}
}
return null;
}
Array.prototype.indexOf should do some fix in IE.
Without having a complete list of TLD's (which would get very long). If you just need the domain name from the current page you can use my technique (using cookies to find the root domain)
Javascript - Get Domain Name Excluding Subdomain
To remove the extension you can then use the first element from a str.split('.')[0]
It's simple:
var tokens = document.domain.split('.');
var domain = tokens[tokens.length - 2];
i needed to do this and whipped up something simple that accounted for my use case
function stripSubDomainAndTLD (domain) {
return domain.replace(/^(?:[a-z0-9\-\.]+\.)??([a-z0-9\-]+)(?:\.com|\.net|\.org|\.biz|\.ws|\.in|\.me|\.co\.uk|\.co|\.org\.uk|\.ltd\.uk|\.plc\.uk|\.me\.uk|\.edu|\.mil|\.br\.com|\.cn\.com|\.eu\.com|\.hu\.com|\.no\.com|\.qc\.com|\.sa\.com|\.se\.com|\.se\.net|\.us\.com|\.uy\.com|\.ac|\.co\.ac|\.gv\.ac|\.or\.ac|\.ac\.ac|\.af|\.am|\.as|\.at|\.ac\.at|\.co\.at|\.gv\.at|\.or\.at|\.asn\.au|\.com\.au|\.edu\.au|\.org\.au|\.net\.au|\.id\.au|\.be|\.ac\.be|\.adm\.br|\.adv\.br|\.am\.br|\.arq\.br|\.art\.br|\.bio\.br|\.cng\.br|\.cnt\.br|\.com\.br|\.ecn\.br|\.eng\.br|\.esp\.br|\.etc\.br|\.eti\.br|\.fm\.br|\.fot\.br|\.fst\.br|\.g12\.br|\.gov\.br|\.ind\.br|\.inf\.br|\.jor\.br|\.lel\.br|\.med\.br|\.mil\.br|\.net\.br|\.nom\.br|\.ntr\.br|\.odo\.br|\.org\.br|\.ppg\.br|\.pro\.br|\.psc\.br|\.psi\.br|\.rec\.br|\.slg\.br|\.tmp\.br|\.tur\.br|\.tv\.br|\.vet\.br|\.zlg\.br|\.br|\.ab\.ca|\.bc\.ca|\.mb\.ca|\.nb\.ca|\.nf\.ca|\.ns\.ca|\.nt\.ca|\.on\.ca|\.pe\.ca|\.qc\.ca|\.sk\.ca|\.yk\.ca|\.ca|\.cc|\.ac\.cn|\.com\.cn|\.edu\.cn|\.gov\.cn|\.org\.cn|\.bj\.cn|\.sh\.cn|\.tj\.cn|\.cq\.cn|\.he\.cn|\.nm\.cn|\.ln\.cn|\.jl\.cn|\.hl\.cn|\.js\.cn|\.zj\.cn|\.ah\.cn|\.gd\.cn|\.gx\.cn|\.hi\.cn|\.sc\.cn|\.gz\.cn|\.yn\.cn|\.xz\.cn|\.sn\.cn|\.gs\.cn|\.qh\.cn|\.nx\.cn|\.xj\.cn|\.tw\.cn|\.hk\.cn|\.mo\.cn|\.cn|\.cx|\.cz|\.de|\.dk|\.fo|\.com\.ec|\.tm\.fr|\.com\.fr|\.asso\.fr|\.presse\.fr|\.fr|\.gf|\.gs|\.co\.il|\.net\.il|\.ac\.il|\.k12\.il|\.gov\.il|\.muni\.il|\.ac\.in|\.co\.in|\.org\.in|\.ernet\.in|\.gov\.in|\.net\.in|\.res\.in|\.is|\.it|\.ac\.jp|\.co\.jp|\.go\.jp|\.or\.jp|\.ne\.jp|\.ac\.kr|\.co\.kr|\.go\.kr|\.ne\.kr|\.nm\.kr|\.or\.kr|\.li|\.lt|\.lu|\.asso\.mc|\.tm\.mc|\.com\.mm|\.org\.mm|\.net\.mm|\.edu\.mm|\.gov\.mm|\.ms|\.nl|\.no|\.nu|\.pl|\.ro|\.org\.ro|\.store\.ro|\.tm\.ro|\.firm\.ro|\.www\.ro|\.arts\.ro|\.rec\.ro|\.info\.ro|\.nom\.ro|\.nt\.ro|\.se|\.si|\.com\.sg|\.org\.sg|\.net\.sg|\.gov\.sg|\.sk|\.st|\.tf|\.ac\.th|\.co\.th|\.go\.th|\.mi\.th|\.net\.th|\.or\.th|\.tm|\.to|\.com\.tr|\.edu\.tr|\.gov\.tr|\.k12\.tr|\.net\.tr|\.org\.tr|\.com\.tw|\.org\.tw|\.net\.tw|\.ac\.uk|\.uk\.com|\.uk\.net|\.gb\.com|\.gb\.net|\.vg|\.sh|\.kz|\.ch|\.info|\.ua|\.gov|\.name|\.pro|\.ie|\.hk|\.com\.hk|\.org\.hk|\.net\.hk|\.edu\.hk|\.us|\.tk|\.cd|\.by|\.ad|\.lv|\.eu\.lv|\.bz|\.es|\.jp|\.cl|\.ag|\.mobi|\.eu|\.co\.nz|\.org\.nz|\.net\.nz|\.maori\.nz|\.iwi\.nz|\.io|\.la|\.md|\.sc|\.sg|\.vc|\.tw|\.travel|\.my|\.se|\.tv|\.pt|\.com\.pt|\.edu\.pt|\.asia|\.fi|\.com\.ve|\.net\.ve|\.fi|\.org\.ve|\.web\.ve|\.info\.ve|\.co\.ve|\.tel|\.im|\.gr|\.ru|\.net\.ru|\.org\.ru|\.hr|\.com\.hr)$/, '$1');
}
mainly i just wanted to remove all subdomains, unfortunately this isn't 100% for some of the new TLD's but it works pretty well, and you can always add to the regex.
http://jsfiddle.net/icodeforlove/TzjJE/2/
With the help of other friend's code examples given above I created a function which will return only domain name and if it is not valid domain for example TLD is missing then it will attach ".com" as per my requirement.
function getDomain(url){
var TLDs = ["ac", "ad", "ae", "aero", "af", "ag", "ai", "al", "am", "an", "ao", "aq", "ar", "arpa", "as", "asia", "at", "au", "aw", "ax", "az", "ba", "bb", "bd", "be", "bf", "bg", "bh", "bi", "biz", "bj", "bm", "bn", "bo", "br", "bs", "bt", "bv", "bw", "by", "bz", "ca", "cat", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl", "cm", "cn", "co", "com", "coop", "cr", "cu", "cv", "cx", "cy", "cz", "de", "dj", "dk", "dm", "do", "dz", "ec", "edu", "ee", "eg", "er", "es", "et", "eu", "fi", "fj", "fk", "fm", "fo", "fr", "ga", "gb", "gd", "ge", "gf", "gg", "gh", "gi", "gl", "gm", "gn", "gov", "gp", "gq", "gr", "gs", "gt", "gu", "gw", "gy", "hk", "hm", "hn", "hr", "ht", "hu", "id", "ie", "il", "im", "in", "info", "int", "io", "iq", "ir", "is", "it", "je", "jm", "jo", "jobs", "jp", "ke", "kg", "kh", "ki", "km", "kn", "kp", "kr", "kw", "ky", "kz", "la", "lb", "lc", "li", "lk", "lr", "ls", "lt", "lu", "lv", "ly", "ma", "mc", "md", "me", "mg", "mh", "mil", "mk", "ml", "mm", "mn", "mo", "mobi", "mp", "mq", "mr", "ms", "mt", "mu", "museum", "mv", "mw", "mx", "my", "mz", "na", "name", "nc", "ne", "net", "nf", "ng", "ni", "nl", "no", "np", "nr", "nu", "nz", "om", "org", "pa", "pe", "pf", "pg", "ph", "pk", "pl", "pm", "pn", "pr", "pro", "ps", "pt", "pw", "py", "qa", "re", "ro", "rs", "ru", "rw", "sa", "sb", "sc", "sd", "se", "sg", "sh", "si", "sj", "sk", "sl", "sm", "sn", "so", "sr", "st", "su", "sv", "sy", "sz", "tc", "td", "tel", "tf", "tg", "th", "tj", "tk", "tl", "tm", "tn", "to", "tp", "tr", "travel", "tt", "tv", "tw", "tz", "ua", "ug", "uk", "us", "uy", "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu", "wf", "ws", "xn--0zwm56d", "xn--11b5bs3a9aj6g", "xn--3e0b707e", "xn--45brj9c", "xn--80akhbyknj4f", "xn--90a3ac", "xn--9t4b11yi5a", "xn--clchc0ea0b2g2a9gcd", "xn--deba0ad", "xn--fiqs8s", "xn--fiqz9s", "xn--fpcrj9c3d", "xn--fzc2c9e2c", "xn--g6w251d", "xn--gecrj9c", "xn--h2brj9c", "xn--hgbk6aj7f53bba", "xn--hlcj6aya9esc7a", "xn--j6w193g", "xn--jxalpdlp", "xn--kgbechtv", "xn--kprw13d", "xn--kpry57d", "xn--lgbbat1ad8j", "xn--mgbaam7a8h", "xn--mgbayh7gpa", "xn--mgbbh1a71e", "xn--mgbc0a9azcg", "xn--mgberp4a5d4ar", "xn--o3cw4h", "xn--ogbpf8fl", "xn--p1ai", "xn--pgbs0dh", "xn--s9brj9c", "xn--wgbh1c", "xn--wgbl6a", "xn--xkc2al3hye2a", "xn--xkc2dl3a5ee0h", "xn--yfro4i67o", "xn--ygbi2ammx", "xn--zckzah", "xxx", "ye", "yt", "za", "zm", "zw"].join()
url = url.replace(/.*?:\/\//g, "");
url = url.replace(/www./g, "");
var parts = url.split('/');
url = parts[0];
var parts = url.split('.');
if (parts[0] === 'www' && parts[1] !== 'com'){
parts.shift()
}
var ln = parts.length
, i = ln
, minLength = parts[parts.length-1].length
, part
// iterate backwards
while(part = parts[--i]){
// stop when we find a non-TLD part
if (i === 0 // 'asia.com' (last remaining must be the SLD)
|| i < ln-2 // TLDs only span 2 levels
|| part.length < minLength // 'www.cn.com' (valid TLD as second-level domain)
|| TLDs.indexOf(part) < 0 // officialy not a TLD
){
var actual_domain = part;
break;
//return part
}
}
//console.log(actual_domain);
var tid ;
if(typeof parts[ln-1] != 'undefined' && TLDs.indexOf(parts[ln-1]) >= 0)
{
tid = '.'+parts[ln-1];
}
if(typeof parts[ln-2] != 'undefined' && TLDs.indexOf(parts[ln-2]) >= 0)
{
tid = '.'+parts[ln-2]+tid;
}
if(typeof tid != 'undefined')
actual_domain = actual_domain+tid;
else
actual_domain = actual_domain+'.com';
return actual_domain;
}
You could use document.domain to determine the domain name of the current page.
When setting document.domain, an error is thrown if the new value is invalid. A plain eTLD is invalid, while an eTLD+1 is valid. The function below loops to find a valid value, then returns the domain name portion.
This is comprehensive, because the browser uses the Public Suffix List to validate new values.
function getDomainName() {
const original = document.domain;
const parts = location.hostname.split('.');
let etld = parts.pop();
while (parts.length) {
const name = parts.pop();
const test = name + '.' + etld;
try {
document.domain = test;
// we found the eTLD+1
// reset before returning
document.domain = original;
return name;
} catch (e) {
// eTLDs and eTLD fragments fail
etld = test;
}
}
}
What about this?
function getDomain(){
if(document.domain.length){
var parts = document.domain.replace(/^(www\.)/,"").split('.');
//is there a subdomain?
while(parts.length > 2){
//removing it from our array
var subdomain = parts.shift();
}
//getting the remaining 2 elements
var domain = parts.join('.');
return domain.replace(/(^\.*)|(\.*$)/g, "");
}
return '';
}
RegEx I use to get domain name only: ([^.]*[.]){0,}([^.]*)(\.[^.]*)
The domain can be found in the second part.
function getDomainName( hostname ) {
var TLDs = new RegExp(/\.(com|net|org|biz|ltd|plc|edu|mil|asn|adm|adv|arq|art|bio|cng|cnt|ecn|eng|esp|etc|eti|fot|fst|g12|ind|inf|jor|lel|med|nom|ntr|odo|ppg|pro|psc|psi|rec|slg|tmp|tur|vet|zlg|asso|presse|k12|gov|muni|ernet|res|store|firm|arts|info|mobi|maori|iwi|travel|asia|web|tel)(\.[a-z]{2,3})?$|(\.[^\.]{2,3})(\.[^\.]{2,3})$|(\.[^\.]{2})$/);
return hostname.replace(TLDs, '').split('.').pop();
}
/* TEST */
var domains = [
'domain.com',
'subdomain.domain.com',
'www.subdomain.domain.com',
'www.subdomain.domain.info',
'www.subdomain.domain.info.xx',
'mail.subdomain.domain.co.uk',
'mail.subdomain.domain.xxx.yy',
'mail.subdomain.domain.xx.yyy',
'mail.subdomain.domain.xx',
'domain.xx'
];
var result = [];
for (var i = 0; i < domains.length; i++) {
result.push( getDomainName( domains[i] ) );
}
alert ( result.join(' | ') );
// result: domain | domain | domain | domain | domain | domain | domain | domain | domain | domain