JavaScript를 사용하여 문자열을 제목 대/소문자로 변환

JavaScript를 사용하여 문자열을 제목 대/소문자로 변환

g e e 、 소 e e e e ?:john smith becomes가 되다John SmithJohn Resig의 솔루션과 같은 복잡한 것을 찾는 것이 아니라 (희망적으로) 원라이너나 투라이너 같은 것을 찾고 있습니다.

이것을 시험해 보세요.

function toTitleCase(str) {
  return str.replace(
    /\w\S*/g,
    function(txt) {
      return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
    }
  );
}

<form>
  Input:
  <br /><textarea name="input" onchange="form.output.value=toTitleCase(this.value)" onkeyup="form.output.value=toTitleCase(this.value)"></textarea>
  <br />Output:
  <br /><textarea name="output" readonly onclick="select(this)"></textarea>
</form>

CSS 솔루션이 요구를 충족하는 경우 텍스트 변환 CSS 스타일을 컨트롤에 적용할 수 있습니다.

text-transform: capitalize;

변한다는 해 주세요.
hello world로로 합니다.Hello World
HELLO WORLD로로 합니다.HELLO WORLD 없음)(변경 없음)
emily-jane o'brien로로 합니다.Emily-jane O'brien (카메라에)
Maria von Trapp로로 합니다.Maria Von Trapp (카메라에)

Greg Dean의 기능을 채택한 조금 더 우아한 방법:

String.prototype.toProperCase = function () {
    return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
};

다음과 같이 부릅니다.

"pascal".toProperCase();

여기 제 버전이 있습니다. IMO는 이해하기 쉽고 우아합니다.

const str = "foo bar baz";
const newStr = str.split(' ')
   .map(w => w[0].toUpperCase() + w.substring(1).toLowerCase())
   .join(' ');
console.log(newStr);

제목 대소문자로 변환하고 정의된 두문자어를 대문자와 소문자로 보존하는 기능은 다음과 같습니다.

String.prototype.toTitleCase = function() {
  var i, j, str, lowers, uppers;
  str = this.replace(/([^\W_]+[^\s-]*) */g, function(txt) {
    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
  });

  // Certain minor words should be left lowercase unless 
  // they are the first or last words in the string
  lowers = ['A', 'An', 'The', 'And', 'But', 'Or', 'For', 'Nor', 'As', 'At', 
  'By', 'For', 'From', 'In', 'Into', 'Near', 'Of', 'On', 'Onto', 'To', 'With'];
  for (i = 0, j = lowers.length; i < j; i++)
    str = str.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'), 
      function(txt) {
        return txt.toLowerCase();
      });

  // Certain words such as initialisms or acronyms should be left uppercase
  uppers = ['Id', 'Tv'];
  for (i = 0, j = uppers.length; i < j; i++)
    str = str.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'), 
      uppers[i].toUpperCase());

  return str;
}

예를 들어 다음과 같습니다.

"TO LOGIN TO THIS SITE and watch tv, please enter a valid id:".toTitleCase();
// Returns: "To Login to This Site and Watch TV, Please Enter a Valid ID:"

저는 다른 답변보다 다음을 선호합니다.각 단어의 첫 글자만 일치하고 대문자로 표시합니다.코드도 심플하고 읽기 쉽고 바이트 수도 적습니다.기존 대문자를 유지하여 약어가 왜곡되지 않도록 합니다., 든지 전화할 수 .toLowerCase()먼저 끈에 매달아주세요.

function title(str) {
  return str.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}

할 수 , 「이러다」를 할 수 있습니다.이것에 의해, 다음의 조작이 가능하게 됩니다.'my string'.toTitle()음음음같 뭇매하다

String.prototype.toTitle = function() {
  return this.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}

예:

String.prototype.toTitle = function() {
  return this.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}

console.log('all lower case ->','all lower case'.toTitle());
console.log('ALL UPPER CASE ->','ALL UPPER CASE'.toTitle());
console.log("I'm a little teapot ->","I'm a little teapot".toTitle());

할 수 요.toLowerCase 그 에 그냥 "" "" " " " " " " " " " "toUpperCase1개의 가 됩니다.1번으로 하다

function titleCase(str) {
  return str.toLowerCase().replace(/\b\w/g, s => s.toUpperCase());
}

console.log(titleCase('iron man'));
console.log(titleCase('iNcrEdible hulK'));

벤치마크

TL;DR

이 벤치마크의 승자는 일반 루프입니다.

function titleize(str) {
    let upper = true
    let newStr = ""
    for (let i = 0, l = str.length; i < l; i++) {
        // Note that you can also check for all kinds of spaces  with
        // str[i].match(/\s/)
        if (str[i] == " ") {
            upper = true
            newStr += str[i]
            continue
        }
        newStr += upper ? str[i].toUpperCase() : str[i].toLowerCase()
        upper = false
    }
    return newStr
}
// NOTE: you could beat that using charcode and string builder I guess.

세부 사항

저는 가장 인기 있고 명확한 답변을 취해서 벤치마크를 만들었습니다.

다음은 내 MacBook Pro에 대한 결과입니다.

그리고 완전성을 위해 사용되는 기능은 다음과 같습니다.

str = "the QUICK BrOWn Fox jUMPS oVeR the LAzy doG";
function regex(str) {
  return str.replace(
    /\w\S*/g,
    function(txt) {
      return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
    }
  );
}

function split(str) {
  return str.
    split(' ').
    map(w => w[0].toUpperCase() + w.substr(1).toLowerCase()).
    join(' ');
}

function complete(str) {
  var i, j, str, lowers, uppers;
  str = str.replace(/([^\W_]+[^\s-]*) */g, function(txt) {
    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
  });

  // Certain minor words should be left lowercase unless 
  // they are the first or last words in the string
  lowers = ['A', 'An', 'The', 'And', 'But', 'Or', 'For', 'Nor', 'As', 'At', 
  'By', 'For', 'From', 'In', 'Into', 'Near', 'Of', 'On', 'Onto', 'To', 'With'];
  for (i = 0, j = lowers.length; i < j; i++)
    str = str.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'), 
      function(txt) {
        return txt.toLowerCase();
      });

  // Certain words such as initialisms or acronyms should be left uppercase
  uppers = ['Id', 'Tv'];
  for (i = 0, j = uppers.length; i < j; i++)
    str = str.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'), 
      uppers[i].toUpperCase());

  return str;
}

function firstLetterOnly(str) {
  return str.replace(/\b(\S)/g, function(t) { return t.toUpperCase(); });
}

function forLoop(str) {
  let upper = true;
  let newStr = "";
  for (let i = 0, l = str.length; i < l; i++) {
    if (str[i] == " ") {
      upper = true;
        newStr += " ";
      continue;
    }
    newStr += upper ? str[i].toUpperCase() : str[i].toLowerCase();
    upper = false;
  }
  return newStr;
}

시제품은 매우 나쁜 관행이라고 생각하기 때문에 일부러 변경하지 않았고, 답변에서 그러한 관행을 촉진해서는 안 된다고 생각합니다.이것은 소규모 코드베이스를 사용하는 사용자만 사용할 수 있습니다.

이 벤치마크에 다른 방법을 추가하고 싶다면 답변 링크에 코멘트를 달아주세요!

---

2022년 Mac M1 편집: 새로운 컴퓨터에서는 최신 크롬을 탑재하여 분할이 가능합니다.특정 머신의 퍼포먼스를 중시하는 경우는, 스스로 벤치마크를 실행할 필요가 있습니다.

var result =
  'this is very interesting'.replace(/\b[a-z]/g, (x) => x.toUpperCase())

console.log(result) // This Is Very Interesting

rest 파라미터의 사용에 대해 아무도 언급하지 않아 놀랐습니다.ES6 Rest 파라미터를 사용하는 간단한 라이너입니다.

let str="john smith"
str=str.split(" ").map(([firstChar,...rest])=>firstChar.toUpperCase()+rest.join("").toLowerCase()).join(" ")
console.log(str)

regex를 참조용으로 사용하지 않고 다음을 수행합니다.

String.prototype.toProperCase = function() {
  var words = this.split(' ');
  var results = [];
  for (var i = 0; i < words.length; i++) {
    var letter = words[i].charAt(0).toUpperCase();
    results.push(letter + words[i].slice(1));
  }
  return results.join(' ');
};

console.log(
  'john smith'.toProperCase()
)

만약 당신이 그 필러 워드에 대해 걱정하고 있다면, 당신은 언제든지 그 함수에 대문자로 쓰지 말아야 할 것을 말할 수 있습니다.

/**
 * @param String str The text to be converted to titleCase.
 * @param Array glue the words to leave in lowercase. 
 */
var titleCase = function(str, glue){
    glue = (glue) ? glue : ['of', 'for', 'and'];
    return str.replace(/(\w)(\w*)/g, function(_, i, r){
        var j = i.toUpperCase() + (r != null ? r : "");
        return (glue.indexOf(j.toLowerCase())<0)?j:j.toLowerCase();
    });
};

도움이 되시길 바랍니다.

편집하다

선두 글루 워드를 처리하려면 다음 변수를 하나 더 추적할 수 있습니다.

var titleCase = function(str, glue){
    glue = !!glue ? glue : ['of', 'for', 'and', 'a'];
    var first = true;
    return str.replace(/(\w)(\w*)/g, function(_, i, r) {
        var j = i.toUpperCase() + (r != null ? r : '').toLowerCase();
        var result = ((glue.indexOf(j.toLowerCase()) < 0) || first) ? j : j.toLowerCase();
        first = false;
        return result;
    });
};

문법적으로 올바른 답이 필요한 경우:

이 답변은 "of", "from" 등의 전치사를 고려합니다.출력에 따라 신문에서 볼 수 있는 편집 스타일 제목이 생성됩니다.

ToTitleCase 함수

여기에 나열된 문법 규칙을 고려하는 함수입니다.또한 이 함수는 공백을 통합하고 특수 문자를 제거합니다(필요에 따라 regex 수정).

const toTitleCase = (str) => {
  const articles = ['a', 'an', 'the'];
  const conjunctions = ['for', 'and', 'nor', 'but', 'or', 'yet', 'so'];
  const prepositions = [
    'with', 'at', 'from', 'into','upon', 'of', 'to', 'in', 'for',
    'on', 'by', 'like', 'over', 'plus', 'but', 'up', 'down', 'off', 'near'
  ];

  // The list of spacial characters can be tweaked here
  const replaceCharsWithSpace = (str) => str.replace(/[^0-9a-z&/\\]/gi, ' ').replace(/(\s\s+)/gi, ' ');
  const capitalizeFirstLetter = (str) => str.charAt(0).toUpperCase() + str.substr(1);
  const normalizeStr = (str) => str.toLowerCase().trim();
  const shouldCapitalize = (word, fullWordList, posWithinStr) => {
    if ((posWithinStr == 0) || (posWithinStr == fullWordList.length - 1)) {
      return true;
    }

    return !(articles.includes(word) || conjunctions.includes(word) || prepositions.includes(word));
  }

  str = replaceCharsWithSpace(str);
  str = normalizeStr(str);

  let words = str.split(' ');
  if (words.length <= 2) { // Strings less than 3 words long should always have first words capitalized
    words = words.map(w => capitalizeFirstLetter(w));
  }
  else {
    for (let i = 0; i < words.length; i++) {
      words[i] = (shouldCapitalize(words[i], words, i) ? capitalizeFirstLetter(words[i], words, i) : words[i]);
    }
  }

  return words.join(' ');
}

정확성을 확인하기 위한 유닛 테스트

import { expect } from 'chai';
import { toTitleCase } from '../../src/lib/stringHelper';

describe('toTitleCase', () => {
  it('Capitalizes first letter of each word irrespective of articles, conjunctions or prepositions if string is no greater than two words long', function(){
    expect(toTitleCase('the dog')).to.equal('The Dog'); // Capitalize articles when only two words long
    expect(toTitleCase('for all')).to.equal('For All'); // Capitalize conjunctions when only two words long
    expect(toTitleCase('with cats')).to.equal('With Cats'); // Capitalize prepositions when only two words long
  });

  it('Always capitalize first and last words in a string irrespective of articles, conjunctions or prepositions', function(){
    expect(toTitleCase('the beautiful dog')).to.equal('The Beautiful Dog');
    expect(toTitleCase('for all the deadly ninjas, be it so')).to.equal('For All the Deadly Ninjas Be It So');
    expect(toTitleCase('with cats and dogs we are near')).to.equal('With Cats and Dogs We Are Near');
  });

  it('Replace special characters with space', function(){
    expect(toTitleCase('[wolves & lions]: be careful')).to.equal('Wolves & Lions Be Careful');
    expect(toTitleCase('wolves & lions, be careful')).to.equal('Wolves & Lions Be Careful');
  });

  it('Trim whitespace at beginning and end', function(){
    expect(toTitleCase(' mario & Luigi superstar saga ')).to.equal('Mario & Luigi Superstar Saga');
  });

  it('articles, conjunctions and prepositions should not be capitalized in strings of 3+ words', function(){
    expect(toTitleCase('The wolf and the lion: a tale of two like animals')).to.equal('The Wolf and the Lion a Tale of Two like Animals');
    expect(toTitleCase('the  three Musketeers  And plus ')).to.equal('The Three Musketeers and Plus');
  });
});

제공된 문자열에서 특수 문자를 상당히 많이 삭제하고 있으니 참고하시기 바랍니다.프로젝트의 요건에 대응하려면 정규식을 조정해야 합니다.

위의 솔루션에서 사용되는 regex가 혼란스럽다면 다음 코드를 사용해 보십시오.

function titleCase(str) {
  return str.split(' ').map(function(val){ 
    return val.charAt(0).toUpperCase() + val.substr(1).toLowerCase();
  }).join(' ');
}

'맥도날드' '맥도날드' '오툴' '도라지오' 등 성(타이틀 케이스가 아님)을 다룰 수 있는 기능을 만들었습니다.그러나 독일어나 네덜란드 이름은 "van" 또는 "von"으로 취급하지 않습니다. 종종 소문자로 표기됩니다.나는 "de"가 "Robert de Niro"와 같이 소문자일 때가 많다고 생각한다.이것들은 여전히 다루어져야 할 것이다.

function toProperCase(s)
{
  return s.toLowerCase().replace( /\b((m)(a?c))?(\w)/g,
          function($1, $2, $3, $4, $5) { if($2){return $3.toUpperCase()+$4+$5.toUpperCase();} return $1.toUpperCase(); });
}

코드로 서드파티 라이브러리를 사용할 수 있는 경우 lodash에는 도우미 기능이 있습니다.

https://lodash.com/docs/4.17.3#startCase

_.startCase('foo bar');
// => 'Foo Bar'

_.startCase('--foo-bar--');
// => 'Foo Bar'
 
_.startCase('fooBar');
// => 'Foo Bar'
 
_.startCase('__FOO_BAR__');
// => 'FOO BAR'

ES 6

str.split(' ')
   .map(s => s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase())
   .join(' ')

또 다른

str.split(' ').map(function (s) {
    return s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase();
}).join(' ')

먼저, 당신의 첫 your your your your first 합니다.string공백으로 분할하여 배열로 만듭니다.

var words = str.split(' ');

그런 다음 array.map을 사용하여 대문자로 표시된 단어를 포함하는 새 배열을 만듭니다.

var capitalized = words.map(function(word) {
    return word.charAt(0).toUpperCase() + word.substring(1, word.length);
});

그런 다음 공백으로 새 어레이를 결합합니다.

capitalized.join(" ");

function titleCase(str) {
  str = str.toLowerCase(); //ensure the HeLlo will become Hello at the end
  var words = str.split(" ");

  var capitalized = words.map(function(word) {
    return word.charAt(0).toUpperCase() + word.substring(1, word.length);
  });
  return capitalized.join(" ");
}

console.log(titleCase("I'm a little tea pot"));

주의:

이것은 물론 단점이 있다.이것은 모든 단어의 첫 글자만 대문자로 만들 것이다.즉, 공백으로 구분된 모든 문자열을 1단어로 취급합니다.

아마 다음과 같은 것이 있을 겁니다.

str = "I'm a little/small tea pot";

이렇게 하면

나는 작은/작은 티포트

기대했던 것에 비해

나는 작은/작은 티포트

이 경우 Regex 및 .replace를 사용하면 다음과 같은 이점이 있습니다.

ES6의 경우:

const capitalize = str => str.length
  ? str[0].toUpperCase() +
    str.slice(1).toLowerCase()
  : '';

const escape = str => str.replace(/./g, c => `\\${c}`);
const titleCase = (sentence, seps = ' _-/') => {
  let wordPattern = new RegExp(`[^${escape(seps)}]+`, 'g');
  
  return sentence.replace(wordPattern, capitalize);
};
console.log( titleCase("I'm a little/small tea pot.") );

또는 ES6가 없는 경우:

function capitalize(str) {
  return str.charAt(0).toUpperCase() + str.substring(1, str.length).toLowerCase();
}

function titleCase(str) {
  return str.replace(/[^\ \/\-\_]+/g, capitalize);
}

console.log(titleCase("I'm a little/small tea pot."));

이들 답변의 대부분은 단어 경계 메타문자(\b)의 사용 가능성을 무시하는 것으로 보입니다.이를 활용한 Greg Dean의 답변의 간략한 버전:

function toTitleCase(str)
{
    return str.replace(/\b\w/g, function (txt) { return txt.toUpperCase(); });
}

짐 밥처럼 하이픈으로 연결된 이름에도 효과가 있습니다.

var toMatch = "john w. smith";
var result = toMatch.replace(/(\w)(\w*)/g, function (_, i, r) {
      return i.toUpperCase() + (r != null ? r : "");
    }
)

효과가 있는 것 같은데...위에서 테스트한 결과, "빠른 갈색 여우?" /점프/ ^over! 개.." 및 "C:/프로그램 파일/일부 벤더/두 번째 애플리케이션/a file1.txt"를 참조하십시오.

두 가 필요한 , 두 번째가 아닌 두 번째가 합니다./([a-z])(\w*)/g.

첫 번째 폼은 다음과 같이 단순화할 수 있습니다.

function toTitleCase(toTransform) {
  return toTransform.replace(/\b([a-z])/g, function (_, initial) {
      return initial.toUpperCase();
  });
}

가장 빠른 방법:

str.replace(/(^[a-z])|(\s+[a-z])/g, txt => txt.toUpperCase());

이거 드셔보세요

String.prototype.toProperCase = function(){
    return this.toLowerCase().replace(/(^[a-z]| [a-z]|-[a-z])/g, 
        function($1){
            return $1.toUpperCase();
        }
    );
};

예

var str = 'john smith';
str.toProperCase();

/\S+/g「 」 、 「 」 、 「 」:

function toTitleCase(str) {
  return str.replace(/\S+/g, str => str.charAt(0).toUpperCase() + str.substr(1).toLowerCase());
}

console.log(toTitleCase("a city named örebro")); // A City Named Örebro

단, '선샤인(노란색)' " '선샤인(노란색)'

가장 간단한 것은 css를 사용하는 것이라고 생각합니다.

function format_str(str) {
    str = str.toLowerCase();
    return '<span style="text-transform: capitalize">'+ str +'</span>';
}

"john f. kennedy".replace(/\b\S/g, t => t.toUpperCase())

이것을 실현하기 위한 매우 심플하고 간결한 ES6 기능을 다음에 나타냅니다.

const titleCase = (str) => {
  return str.replace(/\w\S*/g, (t) => { return t.charAt(0).toUpperCase() + t.substr(1).toLowerCase() });
}

export default titleCase;

에 잘 되어 있다utilities폴더 및 다음과 같이 사용됩니다.

import titleCase from './utilities/titleCase.js';

const string = 'my title & string';

console.log(titleCase(string)); //-> 'My Title & String'

악센트 문자(프랑스어에서는 중요!)를 관리하고 하위 예외 처리를 켜거나 끌 수 있는 기능이 있습니다.도움이 됐으면 좋겠다.

String.prototype.titlecase = function(lang, withLowers = false) {
    var i, string, lowers, uppers;

    string = this.replace(/([^\s:\-'])([^\s:\-']*)/g, function(txt) {
        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
    }).replace(/Mc(.)/g, function(match, next) {
        return 'Mc' + next.toUpperCase();
    });

    if (withLowers) {
        if (lang == 'EN') {
            lowers = ['A', 'An', 'The', 'At', 'By', 'For', 'In', 'Of', 'On', 'To', 'Up', 'And', 'As', 'But', 'Or', 'Nor', 'Not'];
        }
        else {
            lowers = ['Un', 'Une', 'Le', 'La', 'Les', 'Du', 'De', 'Des', 'À', 'Au', 'Aux', 'Par', 'Pour', 'Dans', 'Sur', 'Et', 'Comme', 'Mais', 'Ou', 'Où', 'Ne', 'Ni', 'Pas'];
        }
        for (i = 0; i < lowers.length; i++) {
            string = string.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'), function(txt) {
                return txt.toLowerCase();
            });
        }
    }

    uppers = ['Id', 'R&d'];
    for (i = 0; i < uppers.length; i++) {
        string = string.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'), uppers[i].toUpperCase());
    }

    return string;
}

다음은 css(변환하는 텍스트가 대문자인 경우 javascript도 포함)를 사용하는 다른 솔루션입니다.

html

<span id='text'>JOHN SMITH</span>

js

var str = document.getElementById('text').innerHtml;
var return_text = str.toLowerCase();

css

#text{text-transform:capitalize;}

「lewax00」솔루션을 사용하고, 이 심플한 솔루션을 작성했습니다.이 솔루션에서는, 스페이스로부터 「w」또는 「w」가 시작되지만, 여분의 중간 공간은 삭제할 수 없습니다.

"SOFÍA vergara".toLowerCase().replace(/\b(\s\w|^\w)/g, function (txt) { return txt.toUpperCase(); });

결과는 "Sofia Vergara"입니다.

우리는 이곳 사무실에서 논의해 왔고, 사람들이 원하는 방식으로 이름을 입력하는 방식을 자동으로 수정하려고 하는 것은 발생할 수 있는 문제들로 가득 차 있습니다.

우리는 여러 종류의 자동 대문자화가 서로 다른 형태로 분해되는 사례를 생각해 냈는데, 이는 단지 영어 이름만을 위한 것이며, 각 언어마다 고유한 복잡성을 가지고 있습니다.

각 이름의 첫 글자를 대문자로 표시하는 문제:

• IBM과 같은 약어는 입력이 허용되지 않으며 IBM으로 바뀝니다.

• 맥도날드라는 이름이 맥도날드로 바뀌게 되는데, 이는 잘못된 것이며, 맥도날드도 마찬가지입니다.

• 마리통크 같은 이중 통이 있는 이름은 마리통크로 바뀔 것이다.

· O'Connor와 같은 이름은 O'Connor로 바뀝니다.

대부분의 경우 커스텀 규칙을 작성하여 대처할 수 있지만, 이전과 같이 Acronyms에 문제가 있어 새로운 문제가 발생합니다.

·MacDonald 등의 Mac에 이름을 붙이는 규칙을 추가하면 Macy 등의 이름이 MacY로 바뀝니다.

우리가 생각해낸 유일한 해결책은 DBS도 사용하는 것처럼 보이는 모든 문자를 대문자로 바꾸는 것입니다.

따라서 프로세스를 자동화하고 싶다면 모든 이름과 단어의 사전이 없으면 불가능할 뿐만 아니라 모든 것을 망라하는 규칙이 없다면 사용자를 짜증나게 하고 이름을 정확하게 입력하려는 사람들에게 다른 곳으로 이동하도록 유도할 수 있습니다.

언급URL : https://stackoverflow.com/questions/196972/convert-string-to-title-case-with-javascript