blocks|key|90826|text|var+firstNonRepeatedCharacter+=+function(string)+{
++var+chars+=+string.split('');
++for+(var+i+=+0;+i+<+string.length;+i%2B%2B)+{
++++if+(chars.filter(function(j)+{+
++++++++++++++++++++++++return+j+==+string.charAt(i);+
+++++++++++++++}).length+==+1)+return+string.charAt(i);
++}
};|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|90827|因此，我们创建一个包含所有字符的数组，通过对任何字符进行拆分。|unstyled|90828|然后，我们遍历每个字符，并过滤我们创建的数组，因此我们将得到一个只包含这些字符的数组。如果长度曾经是1，我们知道我们有一个不重复的字符。|90829|小提琴：http://jsfiddle.net/2FpZF/|offset|length|90830|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/2FpZF/^0|0|0|0|4|Q|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|F|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

<pre><code>var firstNonRepeatedCharacter = function(string) {
  var chars = string.split('');
  for (var i = 0; i &lt; string.length; i++) {
    if (chars.filter(function(j) { 
                        return j == string.charAt(i); 
               }).length == 1) return string.charAt(i);
  }
};
</code></pre>

<p>So we create an array of all the characters, by splitting on anything.</p>

<p>Then, we loop through each character, and we filter the array we created, so we'll get an array of only those characters.  If the length is ever 1, we know we have a non-repeated character.</p>

<p>Fiddle: <a href="http://jsfiddle.net/2FpZF/" rel="nofollow">http://jsfiddle.net/2FpZF/</a></p>


blocks|key|90840|text|您可以使用indexOf方法查找不重复的字符。如果您查找字符串中的字符，它将是第一个找到的字符，您不会在它后面找到另一个字符：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|90841|function+firstNonRepeatedCharacter(string)+{
++for+(var+i+=+0;+i+<+string.length;+i%2B%2B)+{
++++var+c+=+string.charAt(i);
++++if+(string.indexOf(c)+==+i+&&+string.indexOf(c,+i+%2B+1)+==+-1)+{
++++++return+c;
++++}
++}
++return+null;
}|code-block|syntax|javascript|90842|演示：http://jsfiddle.net/Guffa/Se4dD/|90843|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/Guffa/Se4dD/^0|5|7|0|0|3|W|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

<p>You can use the <code>indexOf</code> method to find the non repeating character. If you look for the character in the string, it will be the first one found, and you won't find another after it:</p>

<pre><code>function firstNonRepeatedCharacter(string) {
  for (var i = 0; i &lt; string.length; i++) {
    var c = string.charAt(i);
    if (string.indexOf(c) == i &amp;&amp; string.indexOf(c, i + 1) == -1) {
      return c;
    }
  }
  return null;
}
</code></pre>

<p>Demo: <a href="http://jsfiddle.net/Guffa/Se4dD/" rel="noreferrer">http://jsfiddle.net/Guffa/Se4dD/</a></p>


blocks|key|90874|text|首先，从1开始循环，而不是0。检查第一个字符看它是否重复是没有意义的，显然不可能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|90875|现在，在您的循环中，有someStringi和someStringi+-+1，它们是当前和以前的字符。|90876|如果someStringi+===+someStringi+-1，则字符重复；如果someStringi+!==+someStringi+-1，则字符不重复，因此返回someStringi|90877|我不会把整件事都写出来，但希望这背后的思考过程会有所帮助|90878|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

<p>First of all, start your loop at 1, not 0. There is no point in checking the first character to see if its repeating, obviously it can't be.</p>

<p>Now, within your loop, you have someString[i] and someString[i - 1]. They are the current and previous characters.</p>

<p>if someString[i] === someString[i - 1] then the characters are repeating, if someString[i] !== someString[i - 1] then they are not repeating, so you return someString[i]</p>

<p>I won't write the whole thing out for you, but hopefully the thought process behind this will help</p>


blocks|key|90910|text|两种进一步的可能性，使用ECMA5数组方法。如果不存在，将返回undefined。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|90911|Javascript|90912|function+firstNonRepeatedCharacter(string)+{
++++return+string.split('').filter(function+(character,+index,+obj)+{
++++++++return+obj.indexOf(character)+===+obj.lastIndexOf(character);
++++}).shift();
}

console.log(firstNonRepeatedCharacter('aabcbd'));|code-block|syntax|javascript|90913|在jsFiddle上|90914|或者如果您想要更好的性能，特别是在更长的字符串上。|90915|90916|function+firstNonRepeatedCharacter(string)+{
++++var+first;

++++string.split('').some(function+(character,+index,+obj)+{
++++++++if(obj.indexOf(character)+===+obj.lastIndexOf(character))+{
++++++++++++first+=+character;
++++++++++++return+true;
++++++++}

++++++++return+false;
++++});

++++return+first;
}

console.log(firstNonRepeatedCharacter('aabcbd'));|90917|90918|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/Xotic750/R3QD6/|1|http://jsfiddle.net/Xotic750/Syf2f/^0|V|9|0|0|0|1|8|0|0|0|0|0|1|8|1|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|O|3|P|5|6|7|1D|8|@]|D|@]|E|$]]|$1|Q|3|G|5|6|7|1E|8|@]|D|@]|E|$]]|$1|R|3|S|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|T|3|N|5|6|7|1G|8|@]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|U|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]|12|$5|X|Y|Z|E|$10|13]]]]

<p>Two further possibilities, using ECMA5 array methods. Will return <code>undefined</code> if none exist.</p>

<p>Javascript</p>

<pre><code>function firstNonRepeatedCharacter(string) {
    return string.split('').filter(function (character, index, obj) {
        return obj.indexOf(character) === obj.lastIndexOf(character);
    }).shift();
}

console.log(firstNonRepeatedCharacter('aabcbd'));
</code></pre>

<p>On <a href="http://jsfiddle.net/Xotic750/R3QD6/" rel="nofollow">jsFiddle</a></p>

<p>Or if you want a bit better performance, especially on longer strings.</p>

<p>Javascript</p>

<pre><code>function firstNonRepeatedCharacter(string) {
    var first;

    string.split('').some(function (character, index, obj) {
        if(obj.indexOf(character) === obj.lastIndexOf(character)) {
            first = character;
            return true;
        }

        return false;
    });

    return first;
}

console.log(firstNonRepeatedCharacter('aabcbd'));
</code></pre>

<p>On <a href="http://jsfiddle.net/Xotic750/Syf2f/" rel="nofollow">jsFiddle</a></p>


blocks|key|90922|text|+function+FirstNotRepeatedChar(str)+{
+var+arr+=+str.split('');
+var+result+=+'';
+var+ctr+=+0;+
++for+(var+x+=+0;+x+<+arr.length;+x%2B%2B)+{
+++ctr+=+0;
++for+(var+y+=+0;+y+<+arr.length;+y%2B%2B)+{
++if+(arr[x]+===+arr[y])+{
++++ctr%2B=+1;
++++}
+++}

if+(ctr+<+2)+{
++result+=+arr[x];
++break;
++}
}
return+result;
}
console.log(FirstNotRepeatedChar('asif+shaik'));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|90923|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> function FirstNotRepeatedChar(str) {
 var arr = str.split('');
 var result = '';
 var ctr = 0; 
  for (var x = 0; x &lt; arr.length; x++) {
   ctr = 0;
  for (var y = 0; y &lt; arr.length; y++) {
  if (arr[x] === arr[y]) {
    ctr+= 1;
    }
   }

if (ctr &lt; 2) {
  result = arr[x];
  break;
  }
}
return result;
}
console.log(FirstNotRepeatedChar('asif shaik'));
</code></pre>


blocks|key|90945|text|用零填充空数组，长度与字符串数组相同，并统计它们在循环中出现的次数。获取计数数组中的第一个值为1的数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|90946|function+firstNotRepeatingCharacter(s)+{
++++const+array+=+s.split("");
++++let+scores+=+new+Array(array.length).fill(0);

++++for+(let+char+of+array)+{
++++++++scores[array.indexOf(char)]%2B%2B;
++++}

++++const+singleChar+=+array[scores.indexOf(1)];
++++return+singleChar+?+singleChar+:+"_"
}|code-block|syntax|javascript|90947|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Fill an empty array with zeros, with same length as the string array, and tally up how many times they appear through the loop. Grab the first one in the tallied array with a value of 1.</p>

<pre><code>function firstNotRepeatingCharacter(s) {
    const array = s.split("");
    let scores = new Array(array.length).fill(0);

    for (let char of array) {
        scores[array.indexOf(char)]++;
    }

    const singleChar = array[scores.indexOf(1)];
    return singleChar ? singleChar : "_"
}
</code></pre>


blocks|key|4597184|text|这是一个有2个ES6集的O(n)解决方案，一个跟踪所有出现过的字符，另一个只跟踪出现过一次的字符。此解决方案利用了Set保留的插入顺序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597185|const+firstNonRepeating+=+str+=>+{
++const+set+=+new+Set();
++const+finalSet+=+new+Set();
++str.split('').forEach(char+=>+{
++++if+(set.has(char))+finalSet.delete(char);
++++else+{
++++++set.add(char);
++++++finalSet.add(char);
++++}
++})
++const+iter+=+finalSet.values();
++return+iter.next().value;
}|code-block|syntax|javascript|4597186|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here's an O(n) solution with 2 ES6 Sets, one tracking all characters that have appeared and one tracking only chars that have appeared once. This solution takes advantage of the insertion order preserved by Set.</p>

<pre><code>const firstNonRepeating = str =&gt; {
  const set = new Set();
  const finalSet = new Set();
  str.split('').forEach(char =&gt; {
    if (set.has(char)) finalSet.delete(char);
    else {
      set.add(char);
      finalSet.add(char);
    }
  })
  const iter = finalSet.values();
  return iter.next().value;
}
</code></pre>


blocks|key|4597210|text|我是在遇到类似问题的时候遇到这个问题的。让我添加我的两行代码。我所做的与Guffa的回答类似。而是同时使用indexOf方法和lastIndexOf。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4597211|我的方法：|4597212|function+nonRepeated(str)+{
+++for(let+i+=+0;+i+<+str.length;+i%2B%2B)+{
++++++let+j+=+str.charAt(i)
++++++if+(str.indexOf(j)+==+str.lastIndexOf(j))+{
++++++++return+j;
++++++}
+++}
+++return+null;
}

nonRepeated("aabcbd");+//c|code-block|syntax|javascript|4597213|简单地说，indexOf()获取字符的第一个匹配项&+lastIndexOf()获取最后一个匹配项。所以当第一次出现也是==最后一次出现时，这意味着只有一个字符。|4597214|entityMap^0|1H|7|1R|B|0|0|0|5|9|R|D|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

<p>I came accross this while facing similar problem. Let me add my 2 lines.
What I did is a similar to the Guffa's answer. But using both <code>indexOf</code> method and <code>lastIndexOf</code>.</p>

<p>My mehod:</p>

<pre><code>function nonRepeated(str) {
   for(let i = 0; i &lt; str.length; i++) {
      let j = str.charAt(i)
      if (str.indexOf(j) == str.lastIndexOf(j)) {
        return j;
      }
   }
   return null;
}

nonRepeated("aabcbd"); //c
</code></pre>

<p>Simply, <code>indexOf()</code> gets first occurrence of a character &amp; <code>lastIndexOf()</code> gets the last occurrence. So when the first occurrence is also == the last occurence, it means there's just one the character.</p>


blocks|key|4597244|text|您可以遍历每个字符以find()返回单个match()的第一个字母。这将导致给定字符串中的第一个非重复字符：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4597245|​|4597246|const+first_nonrepeated_character+=+string+=>+[...string].find(e+=>+string.match(new+RegExp(e,+'g')).length+===+1);
const+string+=+'aabcbd';

console.log(first_nonrepeated_character(string));+//+c|code-block|syntax|javascript|4597247|4597248|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match^0|A|6|K|7|A|6|0|K|7|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]|$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|6|7|18|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|19|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]|V|$5|Q|R|S|E|$T|W]]]]

<p>You can iterate through each character to <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find" rel="nofollow noreferrer"><code>find()</code></a> the first letter that returns a single <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match" rel="nofollow noreferrer"><code>match()</code></a>. This will result in the first non-repeated character in the given string:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const first_nonrepeated_character = string =&gt; [...string].find(e =&gt; string.match(new RegExp(e, 'g')).length === 1);
const string = 'aabcbd';

console.log(first_nonrepeated_character(string)); // c</code></pre>
</div>
</div>
</p>


blocks|key|4597253|text|let+arr+=+[10,+5,+3,+4,+3,+5,+6];
outer:for(let+i=0;i<arr.length;i%2B%2B){
++++for(let+j=0;j<arr.length;j%2B%2B){
++++++++if(arr[i]===arr[j%2B1]){
++++++++++++console.log(arr[i]);
++++++++++++break+outer;
++++++++}
++++}
}


//or+else+you+may+try+this+way...
function+firstDuplicate(arr)+{
++++let+findFirst+=+new+Set()
++++for+(element+of+arr)
++++++++if+(findFirst.has(element+))
++++++++++++return+element+
++++++++else
++++++++++++findFirst.add(element+)
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4597254|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>let arr = [10, 5, 3, 4, 3, 5, 6];
outer:for(let i=0;i&lt;arr.length;i++){
    for(let j=0;j&lt;arr.length;j++){
        if(arr[i]===arr[j+1]){
            console.log(arr[i]);
            break outer;
        }
    }
}


//or else you may try this way...
function firstDuplicate(arr) {
    let findFirst = new Set()
    for (element of arr)
        if (findFirst.has(element ))
            return element 
        else
            findFirst.add(element )
}
</code></pre>


blocks|key|4597279|text|下面是我的解决方案，其时间复杂度为o(n)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597280|function+getfirstNonRepeatingCharacterInAString(params)+{
++++let+count+=+{};
++++for+(let+i+=+0;+i+<+params.length;+i%2B%2B)+{
++++++++let+count1+=+0;
++++++++if+(!count[params.charAt(i)])+{
++++++++++++count[params.charAt(i)]+=+count1+%2B+1;
++++++++}
++++++++else+{
++++++++++++count[params.charAt(i)]+=+count[params.charAt(i)]+%2B+1;
++++++++}
++++}
++++for+(let+key+in+count)+{
++++++++if+(count[key]+===+1)+{
++++++++++++return+key;
++++++++}
++++}
++++return+null;
}
console.log(getfirstNonRepeatingCharacterInAString("GeeksfoGeeks"));|code-block|syntax|javascript|4597281|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here is my solution which have time complexity of o(n)</p>

<pre><code>function getfirstNonRepeatingCharacterInAString(params) {
    let count = {};
    for (let i = 0; i &lt; params.length; i++) {
        let count1 = 0;
        if (!count[params.charAt(i)]) {
            count[params.charAt(i)] = count1 + 1;
        }
        else {
            count[params.charAt(i)] = count[params.charAt(i)] + 1;
        }
    }
    for (let key in count) {
        if (count[key] === 1) {
            return key;
        }
    }
    return null;
}
console.log(getfirstNonRepeatingCharacterInAString("GeeksfoGeeks"));
</code></pre>


blocks|key|4597306|text|下面是我使用forEach并将字符串转换为数组的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597307|function+firstNotRepeatingCharacter(s)+{
++++var+strArr+=+s.split("");
++++var+found+=+"_";
++++strArr.forEach(function(item,+index)+{
++++++++if+(strArr.indexOf(item)+==+index+&&+strArr.indexOf(item,+index+%2B+1)+==+-1)+{
++++++++++++if+(found+===+"_")+{
++++++++++++++++found+=+item;
++++++++++++}
++++++++}
++++})

++++return+found;
}

firstNotRepeatingCharacter("abacabad")|code-block|syntax|javascript|4597308|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my solution using forEach and convert the string into an array
<pre><code>function firstNotRepeatingCharacter(s) {
    var strArr = s.split(&quot;&quot;);
    var found = &quot;_&quot;;
    strArr.forEach(function(item, index) {
        if (strArr.indexOf(item) == index &amp;&amp; strArr.indexOf(item, index + 1) == -1) {
            if (found === &quot;_&quot;) {
                found = item;
            }
        }
    })

    return found;
}

firstNotRepeatingCharacter(&quot;abacabad&quot;)
</code></pre>


blocks|key|4597348|text|这是另一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597349|每次找到相等的字符时，将其存储在一个数组中，并跳出循环。如果在数组中找不到字符，那么就有了第一个nonRepeating字符|4597350|function+nonRepeatingChars(value)+{
++const+memory+=+[]
++for+(let+i+=+0;+i+<+value.length;+i%2B%2B)+{
++++for+(let+j+=+i+%2B+1;+j+<+value.length;+j%2B%2B)+{
++++++if+(value[i]+===+value[j])+{
++++++++memory.push(value[j])
++++++++break;
++++++}
++++}
++++if+(!memory.some(x+=>+x+===+value[i]))+{
++++++return+value[i];
++++}
++}
++return+"all+chars+have+duplicates";
}

console.log('First+non+repeating+char+is:',nonRepeatingChars("esen"))
console.log('First+non+repeating+char+is:',nonRepeatingChars("esesn"))
console.log('First+non+repeating+char+is:',nonRepeatingChars("eseulsn"))
console.log('First+non+repeating+char+is:',nonRepeatingChars("esesnn"))|code-block|syntax|javascript|4597351|​|4597352|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>Here is another approach:</p>

<p>Everytime you find equal chars store it in an array and break out of the loop. If the char is not found in the array then you have your first nonRepeating char
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function nonRepeatingChars(value) {
  const memory = []
  for (let i = 0; i &lt; value.length; i++) {
    for (let j = i + 1; j &lt; value.length; j++) {
      if (value[i] === value[j]) {
        memory.push(value[j])
        break;
      }
    }
    if (!memory.some(x =&gt; x === value[i])) {
      return value[i];
    }
  }
  return "all chars have duplicates";
}

console.log('First non repeating char is:',nonRepeatingChars("esen"))
console.log('First non repeating char is:',nonRepeatingChars("esesn"))
console.log('First non repeating char is:',nonRepeatingChars("eseulsn"))
console.log('First non repeating char is:',nonRepeatingChars("esesnn"))</code></pre>
</div>
</div>
</p>


blocks|key|4597358|text|>+var+firstNonRepeatedCharacter+=+function+(str){+++
>+for(i=0;i<str.length;i%2B%2B){
>+++++if(str.indexOf(str.charAt(i))+===+str.lastIndexOf(str.charAt(i))){
>+++++++console.log(str.charAt(i));
>+++++++break;
>+++++}+++}+}
>+
>+firstNonRepeatedCharacter+("areerak");|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4597359|你可以查看下面的链接|unstyled|4597360|https://codepen.io/t3veni/pen/wvvxJzm|offset|length|4597361|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|11|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|F|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

<pre><code>&gt; var firstNonRepeatedCharacter = function (str){   
&gt; for(i=0;i&lt;str.length;i++){
&gt;     if(str.indexOf(str.charAt(i)) === str.lastIndexOf(str.charAt(i))){
&gt;       console.log(str.charAt(i));
&gt;       break;
&gt;     }   } }
&gt; 
&gt; firstNonRepeatedCharacter ("areerak");
</code></pre>

<p>you can check below link</p>

<p><a href="https://codepen.io/t3veni/pen/wvvxJzm" rel="nofollow noreferrer">https://codepen.io/t3veni/pen/wvvxJzm</a></p>


blocks|key|4597373|text|下面是一个解决方案，使用正则表达式替换所有重复的字符，然后返回第一个字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597374|​|4597375|function+firstNonRepeat(str)+{

+++//+Sorting+str+so+that+all+repeating+characters+will+come+together+&+replacing+it+with+empty+string+and+taking+first+character+using+substr.

+++var+rsl+=+str.split('').sort().join('').replace(/(\w)\1%2B/g,'').substr(0,1);

+++if(rsl)+return+rsl;

+++else+return+'All+characters+are+repeated+in+'+%2B+str;

}

console.log(firstNonRepeat('aaabcccdeeef'));
console.log(firstNonRepeat('aaacbdcee'));
console.log(firstNonRepeat('aabcbd'));|code-block|syntax|javascript|4597376|4597377|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Here's a Solution using Regex to replace all repeating characters and then returning the first character.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function firstNonRepeat(str) {

   // Sorting str so that all repeating characters will come together &amp; replacing it with empty string and taking first character using substr.

   var rsl = str.split('').sort().join('').replace(/(\w)\1+/g,'').substr(0,1);

   if(rsl) return rsl;

   else return 'All characters are repeated in ' + str;

}

console.log(firstNonRepeat('aaabcccdeeef'));
console.log(firstNonRepeat('aaacbdcee'));
console.log(firstNonRepeat('aabcbd'));</code></pre>
</div>
</div>
</p>


blocks|key|91201|text|解决这个算法的简单方法，非常简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|91202|function+firstNonRepeatChar(str){
++++let+map+=+{};
++++for(let+i=0;+i<str.length;+i%2B%2B){
++++++++if(Object.keys(map).includes(str[i])){
++++++++++++map[str[i]]%2B%2B
++++++++}
++++++++else{
++++++++++++map[str[i]]+=+1;
++++++++}
++++}

++++for(let+j=0;+j<+Object.values(map).length;+j%2B%2B){
++++++++if(Object.values(map)[j]+==+1){
++++++++++++console.log(Object.keys(map)[j]);
++++++++++++return
++++++++}
++++++++if+(j+==+Object.values(map).length-1+&&+Object.values(map)[j]+!=+1){
++++++++++++console.log('_');
++++++++++++return;
++++++++}
++++++++else{
++++++++++++continue;
++++++++}
++++}
}

nonRepeat("aaabbcccdeeef");|code-block|syntax|javascript|91203|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Easy way to solve this algorithm, very straight forward.</p>

<pre><code>function firstNonRepeatChar(str){
    let map = {};
    for(let i=0; i&lt;str.length; i++){
        if(Object.keys(map).includes(str[i])){
            map[str[i]]++
        }
        else{
            map[str[i]] = 1;
        }
    }

    for(let j=0; j&lt; Object.values(map).length; j++){
        if(Object.values(map)[j] == 1){
            console.log(Object.keys(map)[j]);
            return
        }
        if (j == Object.values(map).length-1 &amp;&amp; Object.values(map)[j] != 1){
            console.log('_');
            return;
        }
        else{
            continue;
        }
    }
}

nonRepeat("aaabbcccdeeef");
</code></pre>


blocks|key|4597428|text|此解决方案应适用于包含整数和字符串的数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597429|function+firstNoneRepeating(list,+map+=+new+Map())+{
++for+(let+item+of+list)+{
++++if+(map.has(item))+{
++++++map.set(item,+map.get(item)+%2B+1);
++++}+else+{
++++++map.set(item,+1);
++++}
++}
++for+(let+[key,+value]+of+map.entries())+{
++++if+(value+===+1)+{
++++++return+key;
++++}
++}
}
console.log(firstNoneRepeating("aabcbd"));
console.log(firstNoneRepeating([5,+2,+3,+4,+2,+6,+7,+1,+2,+3]));|code-block|syntax|javascript|4597430|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>This solution should works with array with integers and string.</p>

<pre><code>function firstNoneRepeating(list, map = new Map()) {
  for (let item of list) {
    if (map.has(item)) {
      map.set(item, map.get(item) + 1);
    } else {
      map.set(item, 1);
    }
  }
  for (let [key, value] of map.entries()) {
    if (value === 1) {
      return key;
    }
  }
}
console.log(firstNoneRepeating("aabcbd"));
console.log(firstNoneRepeating([5, 2, 3, 4, 2, 6, 7, 1, 2, 3]));

</code></pre>


blocks|key|4597445|text|下面是另一个仅使用数组解决方案，使用26个唯一字符作为数组长度：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597446|​|4597447|var+firstUniqChar+=+(function(s)+{
++++var+arr+=+[];
++++var+str+=+s.toLowerCase();
++++for(let+c+of+str){
++++++let+index+=+c.charCodeAt(0)+-+"a".charCodeAt(0);
++++++arr[index]?+%2B%2Barr[index]:+arr[index]=1;
++++}
++++
++++for(let+c+of+str){
++++++let+index+=+c.charCodeAt(0)+-+97;
++++++if(arr[index]+==+1){
++++++++return+c;
++++++};
++++}

++++return+-1;
}("aabcbd"));

console.log(firstUniqChar);|code-block|syntax|javascript|4597448|4597449|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Here is one other solution just using array, using 26 unique character as length of array:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var firstUniqChar = (function(s) {
    var arr = [];
    var str = s.toLowerCase();
    for(let c of str){
      let index = c.charCodeAt(0) - "a".charCodeAt(0);
      arr[index]? ++arr[index]: arr[index]=1;
    }
    
    for(let c of str){
      let index = c.charCodeAt(0) - 97;
      if(arr[index] == 1){
        return c;
      };
    }

    return -1;
}("aabcbd"));

console.log(firstUniqChar);</code></pre>
</div>
</div>
</p>


blocks|key|91256|text|++++//To+find+first+non+repeating+letter+
++++//It+will+check+for+both+upper+and+lower+case
++++//only+use+one+String.indexOf()

++++var+mystr="ohvhvtccggt";
++++var+checkFirstNonRepeating=function(){
++++var+ele=[];
++++++for(var+i=0;i<mystr.length;i%2B%2B)+{
++++++var+key=mystr.charAt(i);
++++++if(!ele[key])
++++++++++ele[key]=0;
++++++ele[key]%2B%2B;

+++//Just+check+for+second+occurance+of+character+
+++//no+need+to+use+indexOf+twice

+++++++if(mystr.indexOf(key,i%2B1)==-1+&&+ele[key]<2)++
+++++++++return+mystr[i];
+++++++}
+++++return+"All+repeating+letters";
++++}
++++console.log(checkFirstNonRepeating());
++++++++++++++
++++++++/*
++++++++Input++:+"ohvhvtoccggt"
++++++++Output+:+All+repeating+letters
++++++++Input++:"oohjtht"
++++++++Output+:j+
++++++++*/|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|91257|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>    //To find first non repeating letter 
    //It will check for both upper and lower case
    //only use one String.indexOf()

    var mystr=&quot;ohvhvtccggt&quot;;
    var checkFirstNonRepeating=function(){
    var ele=[];
      for(var i=0;i&lt;mystr.length;i++) {
      var key=mystr.charAt(i);
      if(!ele[key])
          ele[key]=0;
      ele[key]++;

   //Just check for second occurance of character 
   //no need to use indexOf twice

       if(mystr.indexOf(key,i+1)==-1 &amp;&amp; ele[key]&lt;2)  
         return mystr[i];
       }
     return &quot;All repeating letters&quot;;
    }
    console.log(checkFirstNonRepeating());
              
        /*
        Input  : &quot;ohvhvtoccggt&quot;
        Output : All repeating letters
        Input  :&quot;oohjtht&quot;
        Output :j 
        */
</code></pre>


blocks|key|91281|text|我使用object跟踪字符串中的字符数，然后返回fa值为1的char。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|91282|​|91283|function+firstNotRepeatingCharacter(s)+{

//+initialize+an+empty+object+to+store+chars

++++let+seen+=+{};
++++let+letter+=+'';

++//+iterate+over+each+char+in+a+string
++//+if+it+is+already+there+increase+value+by+one
++//+else+set+the+value+to+1

++++for(let+char+of+s){
++++++++++++if+(seen[char]){
++++++++++++++++++++seen[char]+%2B=1;
++++++++++++}+else+{
++++++++++++++++++++seen[char]+=+1;
++++++++++++}
++++}

++//+iterate+over+the+new+constructed+object
++//+if+the+value+is+1+and+the+output+variable+is+empty
++//+return+the+associated+key+to+the+value+1
++//+else+return+'_'

++++for(let+v+in+seen){
++++++++while(seen[v]+==+1+&&+letter+===+''){
++++++++++++letter+%2B=+v;
++++++++++++return+letter;
++++++++}+
++++}
return('_');
}

console.log(firstNotRepeatingCharacter("abacabad"));
console.log(firstNotRepeatingCharacter("cbc"));
console.log(firstNotRepeatingCharacter("bcccccccccccccyb"));
console.log(firstNotRepeatingCharacter("aaa"));|code-block|syntax|javascript|91284|91285|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>I used object to keep track of characters count in a string then return the char that has the fa value of 1. Here is a demo:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function firstNotRepeatingCharacter(s) {

// initialize an empty object to store chars

    let seen = {};
    let letter = '';

  // iterate over each char in a string
  // if it is already there increase value by one
  // else set the value to 1

    for(let char of s){
            if (seen[char]){
                    seen[char] +=1;
            } else {
                    seen[char] = 1;
            }
    }

  // iterate over the new constructed object
  // if the value is 1 and the output variable is empty
  // return the associated key to the value 1
  // else return '_'

    for(let v in seen){
        while(seen[v] == 1 &amp;&amp; letter === ''){
            letter += v;
            return letter;
        } 
    }
return('_');
}

console.log(firstNotRepeatingCharacter("abacabad"));
console.log(firstNotRepeatingCharacter("cbc"));
console.log(firstNotRepeatingCharacter("bcccccccccccccyb"));
console.log(firstNotRepeatingCharacter("aaa"));</code></pre>
</div>
</div>
</p>


blocks|key|91309|text|最令人满意且易于理解的答案如下。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|91310|function+firstNotRepeatingCharacter(s)+{
++++++++
++++const+arr+=+s.split("");

++++for(let+i+=+0;+i+<+arr.length;+i%2B%2B){
++++++++let+chr+=+arr[i];
++++++++if(+arr.indexOf(arr[i])+==+arr.lastIndexOf(arr[i])){
++++++++++++return+arr[i]
++++++++}++++++++++++
++++}
++++
++++return+"_"
}|code-block|syntax|javascript|91311|说明:它从向前和向后遍历字符串的所有字符，然后比较这些值。如果前向和后向搜索的索引都为真，则返回该字符。|91312|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>The most satisfactory and easy to understand answer is the following.</p>
<pre><code>function firstNotRepeatingCharacter(s) {
        
    const arr = s.split(&quot;&quot;);

    for(let i = 0; i &lt; arr.length; i++){
        let chr = arr[i];
        if( arr.indexOf(arr[i]) == arr.lastIndexOf(arr[i])){
            return arr[i]
        }            
    }
    
    return &quot;_&quot;
}
</code></pre>
<p>Explanation: It loops through all the characters of a string from forward and backward and then compares the values. If the index of both forward and backward search is true then it returns that character.</p>


blocks|key|4597528|text|let+str='aabcbd'
let+ans=''
for+(let+i=0;i<str.length;i%2B%2B){
++++if(str.indexOf(str.charAt(i))===str.lastIndexOf(str.charAt(i))){
++++ans%2B=str.charAt(i)
++++break
++++}
}
console.log(ans)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4597529|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>let str='aabcbd'
let ans=''
for (let i=0;i&lt;str.length;i++){
    if(str.indexOf(str.charAt(i))===str.lastIndexOf(str.charAt(i))){
    ans+=str.charAt(i)
    break
    }
}
console.log(ans)
</code></pre>


blocks|key|91334|text|let+str+=+'aabbcdd';
let+val+=+str.split('').reduce((a,+e)=>{+if(str.indexOf(e)+==+str.lastIndexOf(e))+{a+=+e+};+return+a})
console.log(val);+//+c|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|91335|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>let str = 'aabbcdd';
let val = str.split('').reduce((a, e)=&gt;{ if(str.indexOf(e) == str.lastIndexOf(e)) {a = e }; return a})
console.log(val); // c
</code></pre>


blocks|key|91364|text|下面的实现具有很好的时间复杂度，并且考虑了不同大小写的字母：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|91365|步骤必须接触字符串中的每个字符，才能知道它是否重复|91366|function+firstNonRepeatingLetter(wordd)+{

++++const+chars+=+{}

++++let+word+=+wordd.toLowerCase()

++++//+go+through+chars
++++//+store+chars+in+hash+with+values+of+array+storing+index+of+char+and+true+if+only+1+encountered+so+far
++++for+(let+i+=+0;+i+<+word.length;+i+%2B=+1)+{
++++++++let+char+=+word[i]
++++++++if+(chars[char])+{
++++++++++++chars[char][0]+=+false
++++++++}+else+{
++++++++++++chars[char]+=+[true,+i]
++++++++}
++++}
++++let+output+=+''
++++let+index;
++++for+(let+key+in+chars)+{
++++//+return+char+with+true+and+lowest+index
++++++++if+(chars[key][0])+{
++++++++++++index+=+index+===+undefined+?+chars[key][1]+:+index
++++++++++++if+(index+>=+chars[key][1])+{
++++++++++++++++output+=+key
++++++++++++}
++++++++}
++++}
++++return+index+===+undefined+?+''+:+wordd[index]
}
console.log(firstNonRepeatingLetter('sTreSS'))+//T```|code-block|syntax|javascript|91367|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>the implementation below has a good time complexity and it accounts for letters with different cases:</p>
<p>steps
must touch every character in the string to know if it's repeated or not</p>
<pre><code>function firstNonRepeatingLetter(wordd) {

    const chars = {}

    let word = wordd.toLowerCase()

    // go through chars
    // store chars in hash with values of array storing index of char and true if only 1 encountered so far
    for (let i = 0; i &lt; word.length; i += 1) {
        let char = word[i]
        if (chars[char]) {
            chars[char][0] = false
        } else {
            chars[char] = [true, i]
        }
    }
    let output = ''
    let index;
    for (let key in chars) {
    // return char with true and lowest index
        if (chars[key][0]) {
            index = index === undefined ? chars[key][1] : index
            if (index &gt;= chars[key][1]) {
                output = key
            }
        }
    }
    return index === undefined ? '' : wordd[index]
}
console.log(firstNonRepeatingLetter('sTreSS')) //T```
</code></pre>


blocks|key|4597609|text|下面的解是一种频率计数器模式，它只运行一次循环，因此O(n)将是时间复杂度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597610|function+firstNotRepeatingCharacter(str)+{
++const+obj+=+{};
++for+(let+i+=+0,+L+=+str.length;+i+<+L;+i%2B%2B)+{
++++const+char+=+str[i];
++++obj[char]+=+obj[char]+?+obj[char]+%2B+1+:+1;
++}

++for+(let+key+of+Object.keys(obj))+{
++++if+(obj[key]+==+1)+{
++++++return+key;
++++}
++}
++return+-1;
}|code-block|syntax|javascript|4597611|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>The bellow solution is a kind of frequency counter pattern and it will run only one loop, so O(n) will be the time complexity.</p>
<pre><code>function firstNotRepeatingCharacter(str) {
  const obj = {};
  for (let i = 0, L = str.length; i &lt; L; i++) {
    const char = str[i];
    obj[char] = obj[char] ? obj[char] + 1 : 1;
  }

  for (let key of Object.keys(obj)) {
    if (obj[key] == 1) {
      return key;
    }
  }
  return -1;
}
</code></pre>


blocks|key|4597655|text|这是另一个解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597656|function+firstNotRepeatingCharacter(s)+{

+++++const+obj+=+{};

++++++for+(let+i+of+s)+{
++++++++if(!obj[i])+{
++++++++++++obj[i]+=+1;
++++++++}+else+if+(obj[i])+{
++++++++++++obj[i]+=+%2Bobj[i]+%2B+1;
++++++++}
++++++}
++++
++++++for+(let+[key,+value]+of+Object.entries(obj))+{
++++++++if(value+==+1)+return+key;
++++++}
++++
++++return+"_"
}|code-block|syntax|javascript|4597657|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here is another solution</p>
<pre><code>function firstNotRepeatingCharacter(s) {

     const obj = {};

      for (let i of s) {
        if(!obj[i]) {
            obj[i] = 1;
        } else if (obj[i]) {
            obj[i] = +obj[i] + 1;
        }
      }
    
      for (let [key, value] of Object.entries(obj)) {
        if(value == 1) return key;
      }
    
    return &quot;_&quot;
}
</code></pre>


blocks|key|4597697|text|我试图在不使用indexof或lastindexof的情况下实现相同的效果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4597698|function+findfirst(str){
++let+chararr+=+str.split("");
++let+uniq+=+[];
++let+obj+=+new+Map();
++for(let+i=0;i<chararr.length;i%2B%2B){
++++if(obj.get(chararr[i])){
++++++obj.set(chararr[i],+false);
++++}
++++else{
++++++obj.set(chararr[i],true);
++++}
++}
++
obj.forEach((v,k)+=>+{if(v){uniq.push(k);}})
return+uniq[0]
}|code-block|syntax|javascript|4597699|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I tried to achieve same without using indexof or lastindexof.</p>
<pre><code>function findfirst(str){
  let chararr = str.split(&quot;&quot;);
  let uniq = [];
  let obj = new Map();
  for(let i=0;i&lt;chararr.length;i++){
    if(obj.get(chararr[i])){
      obj.set(chararr[i], false);
    }
    else{
      obj.set(chararr[i],true);
    }
  }
  
obj.forEach((v,k) =&gt; {if(v){uniq.push(k);}})
return uniq[0]
}
</code></pre>


<p>So I tried looking for this in the search but the closest I could come is a similar answer in several different languages, I would like to use Javascript to do it.</p>

<p>The problem is I have an arbitrary string that I would like to return the first non repeating character.  EX:  'aba' -> would return b
'aabcbd' -> would return c.
This is what I have so far, just a simple for loop to start. </p>

<pre><code>var someString = 'aabcbd';



var firstNonRepeatedCharacter = function(string) {
for(var i = 0; i &lt; someString.length; i++){

}
};
</code></pre>

<p><a href="http://jsfiddle.net/w7F87/" rel="noreferrer">http://jsfiddle.net/w7F87/</a>
Not sure where to go from here</p>


return the first non repeating character in a string in javascript

所以我试着在搜索中寻找这个，但我能找到的最接近的是几种不同语言的相似答案，我想用Javascript来做。问题是我有一个任意的字符串，我想返回第一个不重复的字符。例如：'aba‘->将返回b 'aabcbd’->将返回c。这就是我到目前为止所知道的，只是启动一个简单的for循环。var someString = 'aa...

问返回javascript中字符串中的第一个非重复字符
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问返回javascript中字符串中的第一个非重复字符EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问返回javascript中字符串中的第一个非重复字符
EN