RubyGems - wordref - Versions diffs - 0.0.5 → 0.0.8 - Mend

wordref 0.0.5 → 0.0.8

Files changed (8) hide show

checksums.yaml +5 -5
data/.travis.yml +1 -1
data/fixtures/vcr_cassettes/wordef.yml +59 -0
data/lib/wordref/version.rb +1 -1
data/spec/lib/wordref_spec.rb +4 -1
data/spec/spec_helper.rb +10 -0
data/wordref.gemspec +7 -3
metadata +66 -9

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 643ffe4ebd8d70865ba00fc99609517475be690b
-  data.tar.gz: 094998062cb8402aea15c78b132a34ab295bc184
+SHA256:
+  metadata.gz: b381f4031babba8b54f1fcc4d150db7ca5ff156b25a4bb4c73cc2ad58ff4e6fc
+  data.tar.gz: 651770bccf20605f03a8f5bd1c6cfcb1e3a10b6e48343a57b05d95ea3a3a288c
 SHA512:
-  metadata.gz: 3496c76bfb1456ae7d4af8c9794a8af008ba24fe65a47d2320ad61eb93ff0d724474ceef8d8a868640f2349041aa860aa6af26627e9ba495eaa979a451e21f1a
-  data.tar.gz: bf471cf38773268ed5c0ad79ade7f9a6f18d8ffbec023e49413d39ddfa8e854bc0cb438c7fd241fc90d4870938fc55eacb93d15407c8b0fad2c6d05192ed6a8a
+  metadata.gz: c71d79c0cae4010ea7edfdbfdb1fad9021b6579be9f7f45e427ead47cde00917fe87f2421d5f62f6d0257f485b51267ece8bf79d3abc1b15b53b9bcbaf79a978
+  data.tar.gz: ac75769645d63d8863b38bdde1540c9ee73be1a0b2f88bf6c709289f1a9e80cdb080a3e7da85d0b1d3664964a6bfe80bbea967f3d8a641fb3caff43eeb7d5c6f

data/.travis.yml CHANGED

@@ -1,7 +1,7 @@
 language: ruby
 sudo: false
 rvm:
-- 1.9.2
+- 2.1.0
 - jruby-19mode
 script: rake
 deploy:

data/fixtures/vcr_cassettes/wordef.yml ADDED

@@ -0,0 +1,59 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: http://www.wordreference.com/enfr/car
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      User-Agent:
+      - Mozilla/5.0 (X11; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Cache-Control:
+      - private
+      Content-Type:
+      - text/html; charset=utf-8
+      Vary:
+      - Accept-Encoding
+      Server:
+      - Microsoft-IIS/10.0
+      X-Aspnet-Version:
+      - 4.0.30319
+      Set-Cookie:
+      - 26=0; domain=wordreference.com; expires=Fri, 12-Jan-2018 07:10:19 GMT; path=/
+      - 327=0; domain=wordreference.com; expires=Fri, 12-Jan-2018 07:10:19 GMT; path=/
+      - llang=enfri; domain=wordreference.com; expires=Mon, 11-Jan-2021 07:10:19 GMT;
+        path=/
+      - per24c=1; domain=www.wordreference.com; expires=Fri, 12-Jan-2018 07:10:19
+        GMT; path=/
+      - per24h=1; domain=www.wordreference.com; expires=Fri, 12-Jan-2018 07:10:19
+        GMT; path=/
+      - per_Mc=1; expires=Thu, 01-Feb-2018 04:59:59 GMT; path=/
+      - per_Mc_x=8f9f5673419f4d9fbd2f93496202ca6a; expires=Wed, 11-Jan-2023 07:10:19
+        GMT; path=/
+      - wrexpire=0; domain=wordreference.com; expires=Fri, 12-Jan-2018 07:10:19 GMT;
+        path=/
+      Access-Control-Allow-Headers:
+      - X-Requested-With
+      Access-Control-Allow-Origin:
+      - "*"
+      Date:
+      - Thu, 11 Jan 2018 07:10:19 GMT
+      Content-Length:
+      - '37057'
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        
<!DOCTYPE html>
<html lang="fr" >
<head>
<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
<title>car - English-French Dictionary WordReference.com</title>
<meta name="description" content="car - traduction anglais-français. Forums pour discuter de car, voir ses formes composées, des exemples et poser vos questions. Gratuit.">
<meta http-equiv="Content-Language" content="fr">
<link title="WR English-French" rel="search" type="application/opensearchdescription+xml" href="//www.wordreference.com/2012/OpenSearch.aspx?dict=enfr">
<meta name="google" content="notranslate">
<meta name="viewport" content="width=device-width, initial-scale=0.8, maximum-scale=4, minimum-scale=0.1, target-densitydpi=device-dpi, user-scalable=yes">
<meta property="og:image" content="//www.wordreference.com/images/WR_fbicon_200x200.png" />
<style>
td.nums1{font-weight:bold;color:#5e58c7;vertical-align:top;text-align:right}
td.roman1{font-weight:bold;color:#5e58c7;vertical-align:top;font-size:16px}
span.roman1{font-weight:bold;color:#5e58c7;vertical-align:bottom}
span.b{font-weight:bold}
span.ic,span.i,.bl{font-style:italic;color:#039}
span.r{color:red}
span.supr1{vertical-align:super;color:#039}
span.ac{font-variant:small-caps;color:red;font-weight:bold}
div.trans	{padding:0}
ol.entry li	{margin-top:5px;}
.hide 	{display:none}
.clickable{cursor:pointer}
.small1{font-size:x-small}
.myCustomResult{cursor:pointer}
.lang{background-color:#b7b7b7;color:white;font-weight:bold;padding:1px}
.dark{background-color:#878787}
.ACconj{float:right}
.forum{text-overflow:ellipsis;overflow:hidden}
html{font-size:100%;overflow:auto;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}
body{margin:0;font-size:12px;line-height:1.231;font-family:Arial,"Helvetica Neue",sans-serif;background:white}
body,button,input,select,textarea{font-family:sans-serif;color:#222}
audio:not([controls]){display:none}
a{text-decoration:none;color:#0645ad}
a:hover{text-decoration:underline}
a:visited{color:#819}
a img{border:0}
.mobileblock{display:inline}
.alwaysblock{display:block}
.alwaysblock:active,.alwaysblock:focus,.alwaysblock:hover{color:#dcdcdc}
#container{width:1002px;margin:0 auto;overflow:hidden;box-shadow:0 0 5px 1px #5e58c7;margin-bottom:3px;border-radius:3px;min-width:300px}
#header{background:#5e58c7;position:static;margin:0 auto;height:41px;line-height:38px;border-bottom-left-radius:3px;border-bottom-right-radius:3px;-webkit-border-bottom-left-radius:3px;-webkit-border-bottom-right-radius:3px;-moz-border-radius-bottomleft:3px;-moz-border-radius-bottomright:3px}
#logo{color:#f8f7ff;float:left;font-family:Arial,Helvetica-Bold;font-size:16px;padding-left:16px;white-space:nowrap}
#logo a{color:#f8f7ff;font-family:Arial,Helvetica-Bold;font-size:22px}
#nav{color:#f7f6ff;float:right;font-family:Arial,"Helvetica Neue";font-size:13px;padding-right:13px;padding-top:2px;
    overflow: hidden;
    white-space: nowrap;
    max-width: 45%;
    text-overflow: ellipsis;
}
#nav a{font-weight:bold;color:#f7f6ff;font-size:13px;font-family:Arial,"Helvetica Neue"}
#logo h1{color:#e5e3ff;font-family:Arial,Helvetica;font-size:12px;display:inline}
#ad1{position:static;width:728px;height:86px;margin:6px auto}
#top728{border:0 none;height:90px;overflow:hidden;width:100%}
#ad2{position:static;width:728px;height:90px;margin:6px auto}
#search{height:50px;background:#ebebf2;position:static;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;border:1px #dcdcdc solid}
#search input{background:#fff;border:1px solid #d3d3d3;-moz-border-radius:3px;-webkit-border-radius:3px;border-radius:3px;height:30px;width:280px;font-size:20px;padding-right:2px}
input:-moz-placeholder{color:#b3b3b3}
*[placeholder]{padding-left:5px!important}
#search input:active,#search input:focus{color:black}
#text_form{display: flex;float:left;margin-left:184px;margin-top:6px}
#text_form input.button{border:0;width:12px;height:12px;background-color:#d7d7d7;cursor:pointer;background-position:5px;line-height:31px;vertical-align:bottom;background-image:none;position:relative;bottom:1px;padding:8px 7px 8px 7px}
.inputcontainer{margin-left: 5px;border:solid 1px #b7b7b7;background-color:#d7d7d7;cursor:pointer;line-height:35px;height:32px;text-align:center;border-radius:2px;width:30px;display:inline-block;}
label.custom-select{margin-left: 5px;position:relative;display:inline-block}
.custom-select select{height: 100%;position:relative;border:1px solid #b7b7b7;padding-left: 3px;margin:0;font:inherit;font-size:13px;font-weight:bold;width:164px;outline:0;line-height:1.2;background-color:#d7d7d7;border-radius:2px}
.custom-select select:focus{-webkit-box-shadow:0 0 3px 1px #ccc;-moz-box-shadow:0 0p 3px 1px #ccc;box-shadow:0 0 3px 1px #ccc}
#forumapi{background-repeat:no-repeat;float:right;margin-top:15px;margin-right:9px;white-space:nowrap;font-size:12px}
#forumapi span.bttn a{font-size:14px;font-weight:bold;color:gray;margin-right:-4px;padding:7px;border:1px solid #c9c9c9;background:#f6f6f9}
#forumapi span.forum a{-webkit-border-top-left-radius:5px;-webkit-border-bottom-left-radius:5px;-moz-border-radius-topleft:5px;-moz-border-radius-bottomleft:5px;border-top-left-radius:5px;border-bottom-left-radius:5px}
#forumapi span.api a{-webkit-border-top-right-radius:5px;-webkit-border-bottom-right-radius:5px;-moz-border-radius-topright:5px;-moz-border-radius-bottomright:5px;border-top-right-radius:5px;border-bottom-right-radius:5px}
.content{margin-top:-5px;background-color:#f6f6f9;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;border:1px #dcdcdc solid;overflow:hidden;clear:both}
#contenttable{border-collapse:collapse}
#leftcolumn{width:164px;line-height:1.4;border-right:1px solid #dcdcdc}
#leftcolumn ul{list-style-type:none}
li.synonym{margin-left:auto}
#left{padding-left:0;margin-top:0;font-size:11px}
#left ul li{padding-right:1px}
#left ul{padding-left:15px;padding-right:1px}
#rstitle{margin-top:15px}
#rsinfo{padding-left:25px}
#rstitle,#rsinfo{display:none}
#wrsave{list-style-type:none}
#more{padding-left:17px}
#more p{margin-bottom:0}
.randomword{padding-left:15px}
td .title1{font-size:13px;font-weight:bold;border-bottom:1px solid #dcdcdc;margin-bottom:7px;padding-top:25px;padding-bottom:6px;padding-left:16px;color:#777}
#centercolumn{width:524px;padding:0}
#listen_widget,.conjugate_link{color:#707070;background-color:#f9f9f9;font-size:12px;display:inline-block;white-space:nowrap;padding:3px 0px 2px;border:1px solid #c5c5c5;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;margin-left:0}
#listen_txt{cursor:pointer;}
#listen_txt,.listen_language{top: -1px;padding:7px 7px 5px 0px;position:relative;left:4px;text-transform:uppercase;border-right:1px solid #c5c5c5;margin-right: 1em;}
.conjugate_link{height:10px;font-variant:small-caps;vertical-align:bottom;padding:0 2px 2px 2px;line-height:.7;top:-1px;text-transform:none}
a .listen_language,a.conjugate_link:visited{color:#707070}
#listen_widget a:hover,.conjugate_link:hover{text-decoration:none;font-weight:bold!important}
#listen_widget {overflow: hidden;vertical-align: middle;margin-bottom: 5px;}
#dummyspan{display:none}
#article,#articleHead,#postArticle{padding:0 20px;font-size: 14px;}
#article a,#articleWRD a,#articleHead a{font-size:13px}
#article p,#articleWRD p,#articleHead p{font-size:13px;margin-bottom:3px}
div#article .noword p{font-size:14px}
div#article p#noEntryFound{font-size:12px}
div#article p.tobetranslated{font-size:12px}
div#spellSug{margin-left:2px!important}
#spellSug table{border-style:hidden;border-collapse:collapse}
#spellSug td{border-width:0}
h3.headerWord{display:inline-block;font-family:"Times New Roman";font-size:25px;margin:20px 18px 20px 0}
#footerlink{display:none}
#article p.EngInf{font-size:12px;padding-bottom:0;margin-bottom:5px}
.inflections{font-size:13px;margin-left:10px}
.notfound{padding:2px;border-top:solid #c8c8c8 1px;border-bottom:solid #c8c8c8 1px;background-color:#f8f8f8;margin-top:5px}
.forma{font-weight:bold;color:black}
.mfsp{color:#039;font-style:italic}
.etichetta,.attrverpron{font-variant:small-caps;text-transform:lowercase}
.boxc{display:block;border:1px solid black;padding:5px;background:white}
.bt{display:block}
div.conv{margin-left:20px}
div.notConv{margin-left:0;padding-left:0;border-left:0}
.enmon ul{list-style-type:none;margin-top:0}
ul.subEnt,.subEnt ul,.subEntry ul{margin-top:0;margin-bottom:0;padding-bottom:0}
span.romansp{font-style:normal;font-weight:normal}
ul.sense1{margin-left:-30px}
span.xrhom{vertical-align:super;color:#039}
span.senseGP{display:block}
.senseGP ul li{margin-top:4px;margin-bottom:-4px}
p.subSN{margin-left:40px;margin-top:0;margin-bottom:0;font-size:12px}
span.supr2{color:#039}
span.psg{display:block}
.subEntry span{display:inline}
ul.hEntry{margin-left:-20px}
.espb ul,.espl ul{list-style-type:none}
.thumbs{display:none}
.engthes ul{list-style-type:none;padding-top:0;margin-top:0}
.liSense{margin-left:-40px}
span.syno:hover{text-decoration:underline}
div.tags{display:inline;width:50%;float:right;font-style:italic}
.clickable ul li.liSense ul li.synonym{display:inline-block;font-size:14px}
.clickable ul li.synonym{display:inline-block;font-size:14px}
.tags{color:gray}
.clickable ul li.synonym:after{content:',\00a0'}
.clickable ul li.last:after{content:''}
.reseta{font-weight:bold}
.inps{font-size:12px;border:solid 1px gray;background-color:#f0f0f0;padding-bottom:5px;padding-left:10px;width:80%}
.inps label{font-weight:bold}
.inps input{width:300px}
.addterm{margin-top:5px}
.FTsource{padding-left:30px}
.FTlist{padding-left:60px}
#FTintro{padding-top:5px;padding-bottom:5px}
.wrcopyright{font-family:Verdana;margin-left:20px}
table.WRD{width:100%;border-collapse:collapse;border-top:solid 1px #dcdcdc;border-bottom:solid 1px #dcdcdc;cursor:pointer}
tr.wrtopsection td{padding-bottom:7px;padding-top:7px;font-size:13px;text-align:center}
#articleWRD p.note-othersideonly{margin-left:20px;font-size:12px}
tr.more td{border-bottom:1px solid #dcdcdc}
.POS2{color:#0645ad}
.WRD td{padding:2px}
.WRD td.FrWrd{padding-left:20px}
.WRD td.ToWrd{color:black;padding-right:20px}
td.ToEx,td.FrEx{color:gray}
.To2{font-style:italic}
.dsense {float: right !important;font-style: normal;}
.ltr{direction:ltr}
.notePubl{padding-left:20px!important;padding-right:20px!important}
table.WRD .additional{border-top:solid 1px #dcdcdc}
table.WRDrefl{border-bottom:0;margin-bottom:15px}
.WRreporterror{width:100%;border-collapse:collapse;border-bottom:1px solid #DCDCDC;margin-bottom:40px}
.WRreporterror td{padding-left:2px;padding-right:4px}
.even{background-color:#ebebf2;vertical-align:top}
.odd{vertical-align:top}
:not(.even)+.even,:not(.odd)+.odd{border-top:1px solid #dcdcdc}
.gold{background-color:gold;vertical-align:top}
p#threadsHeader{font-size:13px!important;font-weight:bold;margin-bottom:0;padding:7px 0;text-align:center;border-top:1px solid #dcdcdc}
#lista_link{font-size:13px;margin-bottom:5px;padding-left:60px;border-top:1px solid #dcdcdc;padding-top:13px}
#lista_link ul li{list-style-type:none;direction:ltr}
#lista_link ul{padding-left:0;margin-bottom:5px}
#lista_link a{font-size:13px}
.threadnote{margin-bottom:30px;margin-top:15px;font-weight:bold}
.threadnote ol{font-weight:normal;padding-top:2px;padding-bottom:2px}
.threadalt li{padding:2px 0}
#extra_links{margin-bottom:15px;margin-left:43px}
#extra_links a{display:list-item;padding:2px 0}
#extra_links .boxed.last{border:none!important}
#extra_links a:last-child .boxed{border-bottom:0 none}
p.other_languages{line-height:1.5em;font-size:12px!important}
.FCboxes{margin-top:5px;margin-left:-5px;padding-top:7px;padding-left:10px;border-top:solid 1px #dcdcdc}
.rightcolumn,#rightcolumn{width:304px}
#rightcolumn{border-left:1px solid #dcdcdc}
#rightcolumn,#leftcolumn,#centercolumn{vertical-align:top;}
#wotdCalendar{width:16px;height:17px;display:inline-block;padding-right:3px;}
#AppStore, #GooglePlay{width:150px;height:45px;display:inline-block;}
table.rightcolumn{table-layout:fixed}
table #right{padding-left:18px;margin-top:0}
td.ad{padding-bottom:10px}
td.ad a {display: inherit;}
a.conjugate {margin-left: 0.3em;}
div.plusone{margin-top:3px;margin-left:5px;vertical-align:middle;display:table-cell}
#fb-root iframe{height:70px!important}
.us300c{text-align:center}
#footer{font-size:11px;position:relative;padding-top:7px;padding-bottom:5px}
.footer{width:1000px}
#WHlinksmoved,#WHlinks_forMobile{display:none}
input::-webkit-input-placeholder:focus,input::-webkit-input-placeholder:active{color:#fff!important}
input:-moz-placeholder:focus{color:#fff!important}
input:-ms-input-placeholder:focus{color:#fff!important}
  #accentSelection {
    border: 0;
    text-transform: uppercase;
    color: #707070;
    background: transparent; 
    padding: 2px 0px 0px 3px;
    position: relative;
    top: -1px;
  }
#forumNotes{display:none;margin:5px 0px 25px 0px;}
#forumNotes, #forumNotesLink {font-size:14px !important;font-style:italic;font-weight:bold;}
#forumNotesLink:visited {color:#000;}
#forumNotesLink:hover {color:#0645ad;}
#checkMonoMatch {
    display: block;
    font-size: 14px !important;
    font-weight: 700;
    margin: 2em 0px 1.5em 0px;
    background: #ebebf2;
    padding: 10px;
    border: 1px solid #0645ad;
    border-radius: 8px;
    text-align: center;
    text-decoration: none;
    color: #0645ad;
}
#checkMonoMatch:hover, #checkMonoMatch:visited:hover {
    background: #0645ad;
    color: #ebebf2;
}
.col_link:hover {
    color: #635eff;
}
#checkMonoMatch:visited, .col_link:visited {
    color: #0645ad;
}
#logo a span {
    color:#b2aef4;
}
.virtKbd_holder {
    position: absolute;margin-top: 32px;font-size: 11px;
}
.audio_holder {
    display:none
}
#pronWR {
    font-size:16px;color:#003399;white-space:nowrap;
}
#WHlinks {
    padding-top: 8px;
}
#kbd-logo-cell { display:none;}
.langHeader {
    font-size: 13px;text-decoration: underline;font-weight:bold;
}
#WRmobile {
    text-align:center
}
#gtrans {
    border: 0 none;
}
.alignRight {
    text-align:right;
}
.transUnavailable {
    color: red; font-style: italic
}</style>

<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

  ga('create', 'UA-187118-1', 'auto');
    
  ga('send', 'pageview');

	window.onerror = function(message, file, line) { 
	   var sFormattedMessage = '[' + file + ' (' + line + ')] ' + message; 
	   ga('send', 'exception', {'exDescription': sFormattedMessage,'exFatal': false});
  }
</script>

<script type="text/javascript">
function resizeWR(size){
	document.getElementById("ad1").style.maxWidth = size + 'px';
}
var AdsRecord = [];
</script>

<link rel="apple-touch-icon" sizes="180x180" href="/favicons/apple-touch-icon.png">
<link rel="icon" type="image/png" href="/favicons/favicon-32x32.png" sizes="32x32">
<link rel="icon" type="image/png" href="/favicons/favicon-16x16.png" sizes="16x16">
<link rel="manifest" href="/favicons/manifest.json">
<link rel="mask-icon" href="/favicons/safari-pinned-tab.svg" color="#3660cc">
<meta name="msapplication-config" content="/favicons/browserconfig.xml">
<link rel="shortcut icon" href="/favicons/favicon.ico">
<meta name="theme-color" content="#ffffff">

<script type="text/javascript">var strOrig = "car";var strDic = "enfr";</script>

<style type="text/css">

@media screen
 and (max-width: 769px) 
{
td#leftcolumn,#ad1,#ad1_holder,#ad2,#logo h1,#nav,.OxAd,.eslinks,.mobileremove,td#rightcolumn,#audiodrop a:nth-child(n+3){display:none}#logo{padding-left:10px}.FTlist,.FTsource{padding-left:5px;padding-right:5px}#container{width:100%;position:absolute}#article,#articleWRD,#postArticle,#search{width:inherit;padding-left:3px}#text_form{left:auto;margin-left:auto;margin-top:2px;float:none}#search{height:auto;padding-bottom:3px}#centercolumn,#contenttable,#header,#search,.content{width:auto}.content{min-width:inherit;border:0;margin-top:0}#content{margin-bottom:0}#article,#postArticle{padding:0 3px}#articleWRD{padding:0}h3.headerWord{margin:5px 20px 5px 2px}#WHlinks{display:none}#WHlinksmoved{display:block}#forumapi{display:none}#WHlinksmoved a,.mobileblock{display:block;font-size:1.5em;border-bottom:solid 1px #dcdcdc;margin-top:0;margin-bottom:0;padding-left:5px;padding-top:12px;padding-bottom:12px}#WHlinksmoved a:first-child{border-top:solid 1px #dcdcdc}.first{border-top:solid 1px #dcdcdc;padding-left:0}#footer{margin-top:0;padding-top:0}#WHlinksmoved a:active,#WHlinksmoved a:focus,#WHlinksmoved a:hover,.mobileblock:active,.mobileblock:focus,.mobileblock:hover{color:#dcdcdc}#spellSug table {margin-top: 1em}#spellSug td{padding: 0 15vw 0 0vw;}#spellSug a{line-height: 10vw;font-size:16px !important}#spellSug,#noEntryFound,#collinsdiv,#articleWRD{font-size:16px}#article{font-size:19px}.small1{font-size: small}.WRD td.FrWrd{padding-left:10px}.WRD td.ToWrd{padding-right:5px}td.FrEx2,td.ToEx2{-webkit-text-size-adjust:auto}#footerlink a{font-variant:small-caps;font-size:18px!important}#footerlink{display:inline-block;margin-right:5px;float:right;padding-top:10px}.myCustomResult:active,.myCustomResult:hover{background-color:#5e58c7;color:#fff}

@media only screen and (max-device-width:300px) {
    .WRD td.FrWrd {
        padding-left: 1px;
    }
    #articleWRD {
        font-size: 15px;
    }
    #article {
        font-size: 16px;
    }
    table.WRD {
        width: 100vw;
    }
    ul #tabWR {
        margin-left: 0px !important;
    }
    #headerTabs a, #headerTabs span {
        width: auto !important;
    }
    #centercolumn div#collinsdiv {
        padding: 0px !important;;
    }
}
@media only screen and (max-device-width:560px) {
    div#headerTabs li a, div#headerTabs li span { padding: 2vw 3vw;    font-size: 3vw;}
    .footer td { height: 30px;vertical-align: bottom; }
    .WRreporterror td { height: 30px; vertical-align: bottom; }
    .FTlist a{ font-size:1.3em; margin-right: 0.5vw; margin-left: 0.5vw;}
    .FTlist { line-height: 3vh; }
    #lista_link { line-height: 3.5vh; }
    #lista_link a { font-size: 1.3em; }
    #extra_links { margin-top: 2vh; line-height: 4vh;}
    p.other_languages { line-height: 3.1vh;margin-top: 2vh;}
    p.other_languages a { font-size:1.2em; margin-right: 1.5vw; margin-left: 1.5vw;}
}

@media screen and (max-width: 769px) {
    #fSelect {
        width: 135px;
    }
    label.custom-select {margin-right: 2px;}
    #search input{width:100%}
    #text_form {display:flex;padding: 0px 5px 0px 5px;}
    #myAutoComplete {margin-right: 10px;}
}
}

@media screen and (max-width: 480px) {
    #articleHead, .mobiletop {
        padding: 0px !important;
    }
}
</style>
<!--[if IE 8]>
<style type="text/css">
 #si{top:-2px;line-height:24px;}
 .inputcontainer{position:relative;top:-3px;line-height:31px;}
</style>
<![endif]-->

<!--[if lt IE 8]>
<style type="text/css">
#search{height:50px;border-bottom:0 none;}
#forumapi{display:none;}
#si{line-height:30px;} 
#text_form input.button{bottom:-1px;}
.inputcontainer{height:29px;margin-left:2px;}
.content{z-index:0;margin-top:0px}
/* for audio links disrupting AComplete*/
#listen_widget{display:block;width:151px;}
.listen_language, #listen_txt{position:static}
#left, #rsinfo {margin-left:0;padding-left:0;}
#left ul {margin-left:0;}
body{line-height:normal !important;}
</style>
<![endif]-->


<style type="text/css">
tr.even:hover, tr.odd:hover, tr.evenEx:hover, tr.oddEx:hover{background-color:gold;}.autocomplete-suggestions{text-align:left;cursor:default;border:1px solid #ccc;border-top:0;background:#fff;box-shadow:-1px 1px 3px rgba(0,0,0,.1);position:absolute;display:none;z-index:9999;box-sizing:border-box}.autocomplete-suggestion{position:relative;padding:0 .6em;line-height:23px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;font-size:1.02em;color:#333;border-top:solid 1px #dcdcdc;cursor:pointer}.autocomplete-suggestion b{font-weight:400;color:#1f8dd6}.autocomplete-suggestion.hover{background:#5e58c7;color:#FFF}@media screen and (max-width:769px){.autocomplete-suggestion{font-size:22px;line-height:40px;padding:0.2em .6em;}.autocomplete-suggestion:active{background:#5e58c7;color:#FFF}}
.autocomplete-suggestion.ar {
    direction: rtl;
}table.WRDrefl{border-bottom:none;margin-bottom:15px}.super{color:red;vertical-align:super;font-size:.8em}span.super:hover{text-decoration:none!important}
#ieupgrade{font-weight:700;padding:3px 3px 0 0;margin:3px 3px 0 0}#headerTabs ul{list-style:none;padding:0;margin:0}#headerTabs li{float:left;border:1px solid #bbb;border-bottom-width:0;margin:0}
#headerTabs a, #headerTabs span{text-decoration:none;display:block;background:#eee;padding:.24em 1em;color:#00c;width:8em;text-align:center;cursor:pointer;user-select: none;}
#headerTabs span:hover, #headerTabs a:hover{background:#ddf}
#headerTabs .selected{border-color:#000}
#headerTabs .selected span, #headerTabs .selected a{position:relative;top:1px;background:#F6F6F9;color:#222;font-weight:700}#collinsdiv{display:none}
#headerTabs{margin-top:10px}.noword>p{font-size:14px!important}#articleWRD .wrcopyright{font-size:10px}#tabWR{margin-left:15px!important}
@media only screen and (min-device-width:320px) and (max-device-width:480px) and (-webkit-min-device-pixel-ratio:2) and (orientation:portrait){#listen_txt,.listen_language{font-size:16px!important}}
.notePubl_tr { border: 1px solid black;border-right: 2px solid black;}
::-webkit-input-placeholder { /* WebKit, Blink, Edge */
    color: #ddf;
}
::-moz-placeholder { /* Mozilla Firefox 19+ */
   color:    #ddf;
   opacity:  1;
}
:-ms-input-placeholder { /* Internet Explorer 10-11 */
   color:    #ddf;
}

::-webkit-input-placeholder {
   color: rgba(0,5,143,.4);
}

::-moz-placeholder {
   color: rgba(0,5,143,.4);
}

:-ms-input-placeholder {  
   color: rgba(0,5,143,.4);
}
#tabRev span, #tabRev a {
    width:  auto;
}

</style>

<style>
.tooltip span:not(.ph):not(.rh_sc):not(.ford){z-index:10;display:none;padding:14px 20px;bottom:18px;margin-left:-160px;width:240px;line-height:16px;border-radius:5px;opacity:.8;font-style:normal;text-decoration:none;cursor:default}
.tooltip:hover span:not(.ph):not(.rh_sc):not(.ford){display:inline;position:absolute;border:2px solid #000;color:#EEE;background:#000}.tooltip{display:inline;position:relative}
.tooltip:hover:before{display:inline;border:solid;border-color:#000 transparent;border-width:6px 6px 0;bottom:12px;content:"";position:absolute;z-index:9;font-style:normal;opacity:.8}
@media only screen and (max-device-width: 480px) {
    .FrWrd .tooltip span:not(.ph):not(.rh_sc):not(.ford){ margin-left:-14px !important;bottom: 17px; }
    .ToWrd .tooltip span:not(.ph):not(.rh_sc):not(.ford){ margin-left:-200px !important;bottom: 17px; }
}
.tooltip2 span {top:-30px;border:0;color:#EEE;background:rgba(0,0,0,0.9);z-index:10;display:inline;position:absolute;padding:10px;width:240px;line-height:16px;border-radius:5px;opacity:.9;}
.tooltip2 {display:inline;position:absolute}
.tooltip2:after{opacity: .8;content: '';position: absolute;right: 100%;border-right: 8px solid #000000;border-top: 8px solid transparent;border-bottom: 8px solid transparent;}
.tooltip.tooltipvirtual:hover span:not(.ph):not(.rh_sc):not(.ford) { 
    padding: 10px 10px;
    width: auto;
    white-space: nowrap;
}
#listen_txt:before, #wotdCalendar, #AppStore, #GooglePlay, #search #searchBtn {background:url(https://cdn77w.wordreference.net/2012/style/sprite.png?v=2)} 

#listen_txt:before {
    background-position: 0 -22px;
    width:15px;
    height:15px;
    display:inline-block;
    content:' ';
    margin-right: 4px;
    vertical-align: middle;
    margin-left: 4px;
    margin-bottom: 2.5px;
}

#search #searchBtn{width: 100%;height:25px;cursor: pointer;background-position: 9px 5px;padding: 0;vertical-align: middle;background-repeat: no-repeat;border: none;}

.FrWrd .engusg:before {
    content: "\1F4AC";
    vertical-align: middle;
    margin-right: 3px;
}

@media only screen and (max-width: 769px) {
    .FrWrd .engusg {
        margin-right: 4px;
        font-size: 19px !important;
        vertical-align: middle;
    }
}
#ad_728 {
    position: absolute;
    color: transparent;
}
.heavyUser:hover {
border: 1px solid #6f6e6e;
}
.heavyUser {
    background-color: rgb(255, 255, 200);
    width: 70%;
    text-align: center;
    font-weight: bold;
    margin: 3vh 0vh 1vh 0vh;
    border-radius: 10px;
    padding: 10px;
    border: 1px solid #c5c5c5;
}
.extras {
    margin-top:2vh;
    border-radius: 10px;
    padding: 10px;
}

.extras div:nth-child(n+2) {
    margin-top: 10px;
}

.extras .extra_category {
    font-weight: bold;
}

.WRD tr td:nth-child(2):not(.FrEx):not(.ToEx) {
    width: 48%;
}
.WRD tr td:nth-child(1):not(.FrEx):not(.ToEx) {
    width: 18%;
}
.WRD tr td:nth-child(3):not(.FrEx):not(.ToEx) {
    width: 34%;
}
.WRD td.FrWrd{
    padding-left: 5px;
}
.WRD td.ToWrd{
    padding-right: 5px;
}
</style>
</head>
<body>

<div id="container">

	<!-- header -->
	
<div id="header">
	<div id="logo">
		<a href="/">WordReference<span style="color:#b2aef4">.com</span></a><span class="mobileremove">  |  </span><h1>Dictionnaires de langue en ligne</h1>
	</div>
	
	<div id="nav" >
		<a href="/enfr/">English-French Dictionary</a>
	
	 | <a href="">car</a>
	
	</div>
</div>

<!-- centra adv -->
	<div id="ad1"></div>

	<!-- search -->
		<div id="search">
				
<form method="GET" action="/redirect/translation.aspx" id="text_form" name="sbox" onsubmit="if(document.sbox.dict.value=='enfr'){location.href = '/enfr/' + document.sbox.w.value;return(false);}">
    <div id="myAutoComplete" style="display:inline">
		<input type="text" name="w" id="si" oninvalid="alert('Caractères non valables dans le champ de recherche');" pattern="^[^<>%\\]*$" autocapitalize="none" size="20" maxlength="200" tabindex="1" onKeyDown="keyDown(event)" accesskey="s" title="accesskey: s" value="" placeholder="Recherche"> 
		<div id="myACContainer" style="display:inline"></div>
	</div>
	<label class="custom-select">
		<select size="1" name="dict" tabindex="2" id="fSelect">
<option value='enfr'>English-French</option><option value='fren'>French-English</option><option value='enes'>English-Spanish</option><option value='esen'>Spanish-English</option><option value='enit'>English-Italian</option><option value='iten'>Italian-English</option><option value='enen'>English definition</option><option value='synonyms'>Synonymes anglais</option><option value='esfr'>Español-Français</option><option value='fres'>Français-Español</option><option value='espt'>Español-Português</option><option value='ptes'>Português-Español</option><option value='eses'>Español: definición</option><option value='essin'>Español: sinónimos</option><option value='caca'>Català: definició</option><option value='other'>Suite...</option>
        </select>
	</label>
	<div class="inputcontainer">
        <input type="submit" id="searchBtn" name="B" title="Recherche" tabindex="3" value="">
    </div>

</form>
				<div id="forumapi">
					<span class="forum api bttn"><a href="https://forum.wordreference.com">Forums</a></span>
				</div>
		</div>

<div class="content">
<table id="contenttable">
<!-- left column -->
<tr>

<td id="leftcolumn">
	<ul id="left" class="leftcolumn">
		<li>
		
<ul>
<li class="title1" title="See Also:">Voir également :</li>
</ul>
<ul>
	<li id="link" ><ul><li><a href="/enfr/captivation">captivation</a></li>
<li><a href="/enfr/captivator">captivator</a></li>
<li><a href="/enfr/captive">captive</a></li>
<li><a href="/enfr/captive%20breeding">captive breeding</a></li>
<li><a href="/enfr/captive%20market">captive market</a></li>
<li><a href="/enfr/captivity">captivity</a></li>
<li><a href="/enfr/captor">captor</a></li>
<li><a href="/enfr/capture">capture</a></li>
<li><a href="/enfr/capuchin">capuchin</a></li>
<li><a href="/enfr/capybara">capybara</a></li>
<li><a href="/enfr/car">car</a></li>
<li><a href="/enfr/car%20alarm">car alarm</a></li>
<li><a href="/enfr/car%20allowance">car allowance</a></li>
<li><a href="/enfr/car%20bomb">car bomb</a></li>
<li><a href="/enfr/car%20bombing">car bombing</a></li>
<li><a href="/enfr/car%20boot%20sale">car boot sale</a></li>
<li><a href="/enfr/car%20chase">car chase</a></li>
<li><a href="/enfr/car%20crash">car crash</a></li>
<li><a href="/enfr/car%20hire">car hire</a></li>
<li><a href="/enfr/car%20insurance">car insurance</a></li>
<li><a href="/enfr/car%20journey">car journey</a></li>
</ul></li>
</ul>

<ul>
	<li class="title1" title="Settings">Paramètres :</li>
</ul>
<ul>
	<li>
		<ul>
		<li class="setclick" title="Options">Cliquer sur le mot :
			<div>
				<input type="radio" name="forClicks" value="1" id="cl1" onclick="setClickW(this.id);" checked="checked"><label for="cl1">donne une traduction</label><br>
				<input type="radio" name="forClicks" value="0" id="cl0" onclick="setClickW(this.id);"><label for="cl0">ne donne rien</label>
			</div>
		</li>
		</ul>
	</li>
	<li>
		<ul>
		<li class="setclick" id="rstitle">Recherches récentes :
			<ul id="rsinfo">
			
			<li id="wrsave">		
				<div>
					<input type="checkbox" name="saveWR" id="saveWR" onclick="setSaveWR();"><label for="saveWR">Enregistrer l&#39;historique</label>
				</div>
			</li>
			<li style="list-style-type:none;" id="viewallhistory">
			<a href="/docs/searchHistory.aspx?dict=enfr" target="_blank">Voir tout</a>
				<script type="text/javascript">
				if ('localStorage' in window && window['localStorage'] !== null){
					document.getElementById("rstitle").style.display = 'block';
					document.getElementById("rsinfo").style.display = 'block';
					if ((!localStorage["bWRsaveHistory"]) || (localStorage["bWRsaveHistory"] == "true")) {
						document.getElementById('saveWR').checked = true;
					} else {
						document.getElementById('saveWR').checked = false;
						document.getElementById("viewallhistory").style.display="none";
					};
				}
				</script>
			</li>	
			
			</ul>
		</li>
		</ul>
	</li>
</ul>
<ul>
	<li class="title1" title="Links">Liens :</li>
</ul>
<ul>
	<li>
	<ul>	
<li><a href="/fr/Abbreviations-French.aspx" title="Abbreviations">Abréviations</a></li>
						 <li><a href="/fr/French-Pronunciation.aspx" title="símbolos/pronunciation">Symboles phonétiques</a></li>
						 <li><a href="/docs/French-verbs-followed-by-the-subjunctive.aspx" title="Subjunctive">Subjonctif français</a></li>

	<li><a href="https://forum.wordreference.com/" title="Forums">Forums</a></li>
	<li><a href="/docs/support-wordreference.aspx" title="Support WR">Soutenez WR</a></li>
	
	<li title="Suggestions"><a href="https://forum.wordreference.com/misc/contact">Suggestions</a></li>
	</ul>
	</li>
</ul>

		</li>
	</ul>
</td>

<!-- center column -->
<td id="centercolumn">
<div id="articleHead">


<h3 class="headerWord">car</h3>

<div id="footerlink"><a href="#footer">[links]</a></div>
<div id='listen_widget'><span id='listen_txt'>Listen:</span><input type='hidden' id='audT' value='8' /><div style='display:none'><audio id='aud0' preload='none'><source src='/audio/en/us/us/en012858.mp3' type='audio/mpeg'></audio><audio id='aud1' preload='none'><source src='/audio/en/uk/general/en012858.mp3' type='audio/mpeg'></audio><audio id='aud2' preload='none'><source src='/audio/en/uk/rp/en012858.mp3' type='audio/mpeg'></audio><audio id='aud3' preload='none'><source src='/audio/en/uk/Yorkshire/en012858-55.mp3' type='audio/mpeg'></audio><audio id='aud4' preload='none'><source src='/audio/en/Irish/en012858.mp3' type='audio/mpeg'></audio><audio id='aud5' preload='none'><source src='/audio/en/scot/en012858.mp3' type='audio/mpeg'></audio><audio id='aud6' preload='none'><source src='/audio/en/us/south/en012858.mp3' type='audio/mpeg'></audio><audio id='aud7' preload='none'><source src='/audio/en/Jamaica/en012858.mp3' type='audio/mpeg'></audio></div><span id='audiodrop'><select id='accentSelection'><option title='USA-Neutral pronunciation' value='0' >US</option><option title='Southern UK' value='1' >UK</option><option title='Received Pronunciation (BBC English)' value='2' >UK-RP</option><option title='Uk Yorkshire' value='3' >UK-Yorkshire</option><option title='Irish Pronunciation' value='4' >Irish</option><option title='Scottish Pronunciation' value='5' >Scottish</option><option title='US-Southern pronunciation' value='6' >US Southern</option><option title='Jamaican pronunciation' value='7' >Jamaican</option></select></span></div> &nbsp;<span id='pronWR' style='font-size:16px;color:#003399;white-space:nowrap;' title='UK Pronunciation'>/kɑː/</span><div id='dummyspan'></div><br />
<div id="forumNotes"><a id="forumNotesLink">ⓘ Un ou plusieurs fils de discussions du forum correspondent exactement au terme que vous recherchez</a></div>
<div id="WHlinks" style="padding-top: 8px;">

	<a href="/definition/car">définition</a> |
	<a href="/synonyms/car">Synonymes anglais</a> |
	<a href="/encol/car">collocations anglaises</a> | 
	<a href="/conj/FrVerbs.aspx" title="Conjugate French verbs">Conjugueur</a> |
	<a title="in Context" href='http://www.google.com/search?tbm=nws&amp;ned=us&amp;hl=en&amp;q=%22car%22' target=gg>en contexte</a> |
	<a href='https://www.google.com/search?tbm=isch&amp;safe=active&amp;q=%22car%22' target=gg>images</a>

    <span id='WHlinks_forMobile'>
    <a href='/tools/Tools.aspx#mobileapps'>WR Apps: Android & iPhone</a>
    <a href='http://daily.wordreference.com/'>Word of the day</a>
    </span> 
</div>




<span id='strAnchors'></span>

<br>

</div>
    					<div id="headerTabs"><ul>
					    <li id="tabWR" class="selected">
                        <span>WordReference</span>
                        </li>
					    <li id="tabHC"><span>Collins</span></li>
					    </ul></div>
					    <style>	#collinsdiv, #articleWRD {border-top: 1px #222222 solid;clear:both;}</style>
    
<script>
    var ul  = document.getElementById("headerTabs").querySelector('ul');
    var li  = document.createElement("li");
    var a   = document.createElement("a");

    a.href = "/enfr/reverse/car";
    a.appendChild(document.createTextNode("WR Reverse (100)"));
    a.title = "Translations to &#39;car&#39; on the other side of this WordReference dictionary.";

    li.setAttribute("id", "tabRev");
    li.appendChild(a);
    ul.appendChild(li);
</script>

<script>
document.addEventListener("DOMContentLoaded", function(event) {
    if ((document.getElementById('articleWRD').children.length === 0) && 
    (/.wordreference.com\/(?:.*?)\/reverse\//i.test(document.referrer) === false) &&
    (!document.getElementById('tabHC'))) {
        document.getElementById('articleWRD').innerHTML = '<p style="direction: ltr;">Redirecting you to the reverse page...</p>';
        location.href = "/enfr/reverse/car";
    }
});

</script>
		   

<div id="articleWRD">
<div><p class='wrcopyright'><a name="car99"></a> <span dir='auto'>WordReference English-<span class='ph' data-ph='sLanguage'>French</span> Dictionary © 2018:</span></p></div><table class='WRD' onclick='redirectWR(event,"WRenfr")'><tr class='wrtopsection'><td colspan='3' title='Principal Translations'><strong><span class='ph' data-ph='sMainMeanings'>Principales traductions</span></strong></td></tr><tr class='langHeader' style='font-size: 13px;text-decoration: underline;font-weight:bold;'><td class='FrWrd'>Anglais</td><td></td><td class='ToWrd'>Français</td></tr>
<tr class='even' id='enfr:3487'><td class='FrWrd' ><strong>car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (automobile)</td><td class='ToWrd' >voiture <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>un peu vieilli</i>)</span></td><td class='ToWrd' >automobile, auto <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>familier</i>)</span></td><td class='ToWrd' >bagnole, caisse <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>The car sped down the highway.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>La voiture accéléra sur l'autoroute.</td></tr>
<tr class='odd' id='enfr:3489'><td class='FrWrd' ><strong><a href='/EnglishUsage/carriage#2' target='_blank' class='engusg' title='English Usage information available'></a>car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (railway coach)&nbsp;<span class='dsense' >(<i>transport ferroviaire</i>)</span></td><td class='ToWrd' >wagon <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>de passagers</i>)</span></td><td class='ToWrd' >voiture <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The brakeman uncoupled the cars.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Le technicien découpla les wagons.</td></tr>
<tr class='odd'><td colspan='3' class='wrtopsection'>&nbsp;</td></tr><tr class='wrtopsection'><td colspan='3' title='Additional Translations' class='additional'><strong><span class='ph' data-ph='sAddTrans'>Traductions supplémentaires</span></strong></td></tr><tr class='langHeader' style='font-size: 13px;text-decoration: underline;font-weight:bold;'><td class='FrWrd'>Anglais</td><td></td><td class='ToWrd'>Français</td></tr>
<tr class='even' id='enfr:3488'><td class='FrWrd' ><strong>car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (streetcar)</td><td class='ToWrd' >tramway <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>familier</i>)</span></td><td class='ToWrd' >tram <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>I paid my fare as I stepped into the car.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>J'ai payé mon billet en montant dans le tramway.</td></tr>
<tr class='odd' id='enfr:3490'><td class='FrWrd' ><strong>car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (elevator)</td><td class='ToWrd' >cabine d'ascenseur <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The car stopped on the second floor.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>La cabine d'ascenseur s'arrêta au deuxième étage.</td></tr>
</table>
<table class='WRreporterror'>
<tr class='even more'><td>&nbsp;</td>
<td style='text-align:right;'><a target='WRsug' title='Is something important missing? Report an error or suggest an improvement.' href="/english/suggestions.aspx?w=car&amp;dict=enfr"><span class='ph' data-ph='sReportError'>Un oubli important ? Signalez une erreur ou suggérez une amélioration.</span></a></td></tr></table>
<div id='mobileAd_holder' style='display:none;'></div><div><p class='wrcopyright'><a name="car99"></a> WordReference English-French Dictionary © 2018:</p></div><table class='WRD' id='compound_forms' onclick='redirectWR(event,"WRenfr")'><tr class='wrtopsection'><td colspan='3' title='Compound Forms' id='compounds'><strong>Formes composées</strong></td></tr><tr class='langHeader' style='font-size: 13px;text-decoration: underline;font-weight:bold;'><td class='FrWrd'>Anglais</td><td></td><td class='ToWrd'>Français</td></tr>
<tr class='even' id='enfr:119718'><td class='FrWrd' ><strong>armored car,<br> UK: armoured car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (reinforced vehicle)&nbsp;<span class='dsense' >(<i>pour présidents,...</i>)</span></td><td class='ToWrd' >voiture blindée <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>pour transport d'argent,...</i>)</span></td><td class='ToWrd' >fourgon blindé <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>Brinks company sends its agents in armored cars to collect money from the banks.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'><span class='tooltip'><b>ⓘ</b><span>This sentence is not a translation of the original sentence.</span></span> Les chefs d'État se déplacent souvent en voiture blindée par souci de sécurité.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>La Brinks a envoyé ses agents dans des fourgons blindés pour récolter l'argent des banques.</td></tr>
<tr class='odd' id='enfr:3179576'><td class='FrWrd' ><strong>baggage car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (coach of train for luggage, etc.)&nbsp;<span class='dsense' >(<i>voiture ferroviaire pour bagages</i>)</span></td><td class='ToWrd' >fourgon <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' id='enfr:1103684'><td class='FrWrd' ><strong>baggage car</strong> <em class='POS2'></em></td><td> <i class='Fr2'>US</i></td><td class='ToWrd' >fourgon <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:18228'><td class='FrWrd' ><strong>battery,<br> car battery</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (device supplying power for car's lights, etc.)&nbsp;<span class='dsense' >(<i>d'une voiture</i>)</span></td><td class='ToWrd' >batterie <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The battery died because Wilma left the headlights on all night.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>La batterie était à plat car Wilma avait laissé les phares allumés toute la nuit.</td></tr>
<tr class='even' id='enfr:129474'><td class='FrWrd' ><strong>be hit by a car</strong> <em class='tooltip POS2'>v expr<span><i>verbal expression</i>: Phrase with special meaning functioning as verb--for example, "put their heads together," "come to an end."</span></em></td><td> (be knocked down)</td><td class='ToWrd' >se faire renverser par une voiture<a title="conjugate se faire renverser par une voiture" class='conjugate' href="/conj/FrVerbs.aspx?v=se+faire+renverser+par+une+voiture">⇒</a> <em class='tooltip POS2'>v pron<span><i>verbe pronominal</i>: verbe qui s'utilise avec le pronom réfléchi "se", qui s'accorde avec le sujet. <i>Ex : <b>se regarder</b> : "Je <b>me</b> regarde dans le miroir. Tu <b>te</b> regardes dans le miroir."</i>. Les verbes pronominaux se conjuguent toujours avec l'auxiliaire "être". <i>Ex : "Elle <b>a</b> lavé la voiture" mais "Elle s'<b>est</b> lavée."</i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>Greg crossed the street without checking for traffic, and was consequently hit by a car.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Greg a traversé la rue sans regarder et s'est fait renverser par une voiture.</td></tr>
<tr class='odd' id='enfr:129751'><td class='FrWrd' ><strong>beat-up car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US, slang</i> (car in poor condition)&nbsp;<span class='dsense' >(<i>familier</i>)</span></td><td class='ToWrd' >tacot <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>figuré, familier</i>)</span></td><td class='ToWrd' >tas de ferraille <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>I love my beat-up car, even though it´s covered in dents and scratches.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>J'adore mon tacot même s'il est couvert de bosses et d'égratignures.</td></tr>
<tr class='even' id='enfr:30309'><td class='FrWrd' ><strong><a href='/EnglishUsage/bonnet#1' target='_blank' class='engusg' title='English Usage information available'></a>bonnet</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>UK</i> (hood: part covering car's engine)</td><td class='ToWrd' >capot <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:3118445'><td class='FrWrd' ><strong>bubble car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (small 1950s car)&nbsp;<span class='dsense' >(<i>figuré : petite voiture</i>)</span></td><td class='ToWrd' >pot de yaourt <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >micro-citadine <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >véhicule urbain compact <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' id='enfr:125603'><td class='FrWrd' ><strong>buffet car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (train: refreshments carriage)</td><td class='ToWrd' >voiture-bar <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >voiture-restaurant <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >wagon-restaurant <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>The train doesn't have a buffet car so be sure to bring some snacks for the trip.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Le train n'a pas de voiture-bar alors n'oublie pas de prendre un casse-croûte pour le voyage.</td></tr>
<tr class='odd' id='enfr:3179855'><td class='FrWrd' ><strong>bumper car</strong> <em class='POS2'></em></td><td> (amusement parks)</td><td class='ToWrd' >auto-tamponneuse <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:1106678'><td class='FrWrd' ><strong>business car</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >voiture de fonction <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' id='enfr:130242'><td class='FrWrd' ><strong>by car</strong> <em class='tooltip POS2'>adv<span><i>adverb</i>: Describes a verb, adjective, adverb, or clause--for example, "come <b>quickly</b>," "<b>very</b> rare,"  "happening <b>now</b>," "fall <b>down</b>." </span></em></td><td> (via motor vehicle)</td><td class='ToWrd' >en voiture <em class='tooltip POS2'>adv<span><i>adverbe</i>: modifie un adjectif ou un verbe. Est toujours invariable ! <i>Ex : "Elle est <b>très</b> grande." "Je marche <b>lentement</b>."</i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>By car, you could get from Lansing to Detroit in about two hours.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'><span class='tooltip'><b>ⓘ</b><span>This sentence is not a translation of the original sentence.</span></span> En voiture, le trajet de chez moi jusque chez mes grands-parents dure 3 h 30.</td></tr>
<tr class='even' id='enfr:112030'><td class='FrWrd' ><strong>cable car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (streetcar on cable railway)</td><td class='ToWrd' >tramway <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>familier</i>)</span></td><td class='ToWrd' >tram <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>anglicisme</i>)</span></td><td class='ToWrd' >cable car <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:112029'><td class='FrWrd' ><strong>cable car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (ski lift)</td><td class='ToWrd' >téléphérique, funiculaire <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' id='enfr:125667'><td class='FrWrd' ><strong>car accident</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (automobile crash)</td><td class='ToWrd' >accident de voiture <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>The number of car accidents has fallen in Western Europe over the past 3 years.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'><span class='tooltip'><b>ⓘ</b><span>This sentence is not a translation of the original sentence.</span></span> L'accident de voiture a fait beaucoup de dégâts matériels mais personne n'a été blessé.</td></tr>
<tr class='odd' id='enfr:130326'><td class='FrWrd' ><strong>car bomb</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (incendiary device in an automobile)</td><td class='ToWrd' >voiture piégée <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Un attentat à la voiture piégée a été perpétré cette nuit dans la capitale.</td></tr>
<tr class='even' id='enfr:130328'><td class='FrWrd' ><strong>car boot sale</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>UK</i> (sale of used items in public place)</td><td class='ToWrd' >vide-greniers <em class='tooltip POS2'>nm inv<span><i>nom masculin invariable</i>: nom masculin qui a la même forme au pluriel. <i>Ex : "un <b>?porte-clés</b>, des <b>porte-clés</b>"</i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>There is a car boot sale every week in the town's main car park.</td></tr>
<tr class='odd' id='enfr:130329'><td class='FrWrd' ><strong>car chase</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (pursuit by vehicle)</td><td class='ToWrd' >course-poursuite <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Le conducteur a été blessé lors de la course-poursuite.</td></tr>
<tr class='even' id='enfr:3179920'><td class='FrWrd' ><strong>car coat</strong> <em class='POS2'></em></td><td> (clothing)&nbsp;<span class='dsense' >(<i>manteau</i>)</span></td><td class='ToWrd' >paletot <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >caban <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:125668'><td class='FrWrd' ><strong>car crash</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (automobile accident)</td><td class='ToWrd' >accident de voiture <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The driver was killed in the car crash but the passenger survived.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Le conducteur a été tué dans l'accident de voiture mais le passager a survécu.</td></tr>
<tr class='even' id='enfr:1107123'><td class='FrWrd' ><strong>car ferry</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >transbordeur <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:112116'><td class='FrWrd' ><strong>car frame</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (chassis)</td><td class='ToWrd' >châssis <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' id='enfr:1196334'><td class='FrWrd' ><strong>car heater</strong> <em class='POS2'></em></td><td> <i class='Fr2'>Can</i>&nbsp;<span class='dsense' >(<i>pour voiture</i>)</span></td><td class='ToWrd' >chaufferette <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' id='enfr:125669'><td class='FrWrd' ><strong>car hire</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>UK</i> (vehicle rental)</td><td class='ToWrd' >location de voiture, location de véhicule <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>Low cost airlines can often offer you special low cost car hire too.</td></tr>
<tr class='even' id='enfr:130327'><td class='FrWrd' ><strong>car hood (US),<br> car bonnet (UK)</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (part covering car's engine)</td><td class='ToWrd' >capot de voiture <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:130330'><td class='FrWrd' ><strong>car horn</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (automobile's warning hooter)&nbsp;<span class='dsense' >(<i>®</i>)</span></td><td class='ToWrd' >Klaxon, klaxon <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>vieilli, officiel</i>)</span></td><td class='ToWrd' >avertisseur sonore <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The proper use of the [car] horn is overlooked by a lot of motorists.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Le bon usage du klaxon est ignoré par bon nombre d'automobilistes.</td></tr>
<tr class='even' id='enfr:130331'><td class='FrWrd' ><strong>car keys</strong> <em class='tooltip POS2'>npl<span><i>plural noun</i>: Noun always used in plural form--for example, "jeans," "scissors."</span></em></td><td> (set of keys to unlock and start an automobile)</td><td class='ToWrd' >clés de voiture <em class='tooltip POS2'>nfpl<span><i>nom féminin pluriel</i>: s'utilise avec l'article défini <b>"les"</b>. <i>Ex : "algues"</i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>I lost my car keys, so I had to walk home to get an extra set.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'><span class='tooltip'><b>ⓘ</b><span>This sentence is not a translation of the original sentence.</span></span> Je ne peux pas partir tant qu'on n'a pas remis la main sur mes clés de voiture.</td></tr>
<tr class='odd' id='enfr:112118'><td class='FrWrd' ><strong>car lot</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (car sales area)</td><td class='ToWrd' >parking <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>That vehicle dealership has a huge car lot.</td></tr>
<tr class='even' id='enfr:130332'><td class='FrWrd' ><strong>car maintenance</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (care and repair of an automobile)</td><td class='ToWrd' >entretien (de la voiture) <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>Regular car maintenance helps prolong the life of your car.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>L'entretien de la voiture la gardera en bon état plus longtemps</td></tr>
<tr class='odd' id='enfr:112119'><td class='FrWrd' ><strong>car mileage</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (fuel consumption)</td><td class='ToWrd' >consommation kilométrique <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:112120'><td class='FrWrd' ><strong>car mileage</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (miles travelled)</td><td class='ToWrd' >kilométrage <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:3179921'><td class='FrWrd' ><strong>car park</strong> <em class='POS2'></em></td><td> (parking lot)</td><td class='ToWrd' >parking <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>Can</i>)</span></td><td class='ToWrd' >terrain de stationnement <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' id='enfr:130333'><td class='FrWrd' ><strong>car payment</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (repayment amount on a car-buying loan)</td><td class='ToWrd' >crédit auto <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>I lost my job so I'm afraid I won't be able to make my car payment this month.</td></tr>
<tr class='even'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >crédit <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>J'ai perdu mon emploi alors j'ai bien peur de ne pas pouvoir payer le crédit de ma voiture ce mois-ci.</td></tr>
<tr class='odd' id='enfr:130334'><td class='FrWrd' ><strong>car plates</strong> <em class='tooltip POS2'>npl<span><i>plural noun</i>: Noun always used in plural form--for example, "jeans," "scissors."</span></em></td><td> (vehicle: registration plaques)</td><td class='ToWrd' >plaque d'immatriculation <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >plaque minéralogiques <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>familier</i>)</span></td><td class='ToWrd' >plaque de voiture <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The hit and run happened so fast no one saw the car plates.</td></tr>
<tr class='even' id='enfr:130335'><td class='FrWrd' ><strong>car port</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (covered parking)</td><td class='ToWrd' >abri de voiture, abri pour voiture <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:1073076'><td class='FrWrd' ><strong>car registration document</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >carte grise <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:1164773'><td class='FrWrd' ><strong>car repair shop</strong> <em class='POS2'></em></td><td> <i class='Fr2'>US</i>&nbsp;<span class='dsense' >(<i>atelier</i>)</span></td><td class='ToWrd' >garage <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:112122'><td class='FrWrd' ><strong>car ride</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (journey, outing in a car)</td><td class='ToWrd' >tour en voiture <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >balade en voiture <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >to go for a car ride : (aller) faire un tour en voiture, se promener en voiture <em class='tooltip POS2'>loc v<span><i>locution verbale</i>: groupe de mots fonctionnant comme un verbe. <i>Ex : "faire référence à"</i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >to go for a car ride : se promener en voiture<a title="conjugate to go for a car ride : se promener en voiture" class='conjugate' href="/conj/FrVerbs.aspx?v=to+go+for+a+car+ride+%3a+se+promener+en+voiture">⇒</a> <em class='tooltip POS2'>v pron<span><i>verbe pronominal</i>: verbe qui s'utilise avec le pronom réfléchi "se", qui s'accorde avec le sujet. <i>Ex : <b>se regarder</b> : "Je <b>me</b> regarde dans le miroir. Tu <b>te</b> regardes dans le miroir."</i>. Les verbes pronominaux se conjuguent toujours avec l'auxiliaire "être". <i>Ex : "Elle <b>a</b> lavé la voiture" mais "Elle s'<b>est</b> lavée."</i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>When I was a child, my family went for a car ride every Sunday.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Quand j'étais petit, ma famille faisait un tour en voiture tous les samedis.</td></tr>
<tr class='even' id='enfr:130336'><td class='FrWrd' ><strong>car salesman,<br> plural: car salesmen</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (male: sells automobiles)</td><td class='ToWrd' >concessionnaire <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>A good car salesman will not let you walk away without buying a car.</td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>plutôt familier</i>)</span></td><td class='ToWrd' >vendeur de voitures <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Un bon vendeur de voitures ne vous laissera pas partir tant que vous n'aurez pas acheté une voiture.</td></tr>
<tr class='odd' id='enfr:3089543'><td class='FrWrd' ><strong>car seat</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (child's removable seat in a car)</td><td class='ToWrd' >siège bébé <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >siège auto, siège auto pour bébés <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>A car seat must fit the child correctly.</td></tr>
<tr class='even' id='enfr:130337'><td class='FrWrd' ><strong>car thief</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (<span title='somebody'>[sb]</span> who steals automobiles)</td><td class='ToWrd' >voleur de voiture, voleuse de voiture <em class='POS2'>nm, nf</em></td></tr>
<tr class='odd' id='enfr:1040931'><td class='FrWrd' ><strong>car track</strong> <em class='POS2'></em></td><td>&nbsp;<span class='dsense' >(<i>rallye</i>)</span></td><td class='ToWrd' >piste <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:130338'><td class='FrWrd' ><strong>car trunk,<br> UK: car boot</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (automobile: boot)</td><td class='ToWrd' >coffre d'une voiture <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>régional</i>)</span></td><td class='ToWrd' >malle d'une voiture <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>When we went to the drive-in we would usually sneak in some friends in the car trunk.</td></tr>
<tr class='odd' id='enfr:112123'><td class='FrWrd' ><strong>car wash</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (facility: vehicle cleaning)</td><td class='ToWrd' >station de lavage (de voitures) <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>assez familier</i>)</span></td><td class='ToWrd' >lavage auto <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>My car is so dirty that I must take it to the car wash.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Ma voiture est si sale qu'il faut que je l'amène au lavage auto.</td></tr>
<tr class='even' id='enfr:130339'><td class='FrWrd' ><strong>car window</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (window of an automobile)</td><td class='ToWrd' >vitre <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>She rolled down the car window to say hello to the neighbors.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Elle a baissé la vitre (de la voiture) pour dire bonjour aux voisins.</td></tr>
<tr class='odd' id='enfr:90097'><td class='FrWrd' ><strong>carfare,<br> car fare</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (fee paid for a bus or taxi ride)&nbsp;<span class='dsense' >(<i>en bus</i>)</span></td><td class='ToWrd' >prix du ticket, prix du trajet <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>en taxi</i>)</span></td><td class='ToWrd' >prix de la course <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' id='enfr:59516'><td class='FrWrd' ><strong>carpool,<br> car pool</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (car-sharing arrangement)</td><td class='ToWrd' >covoiturage <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>Mandy and her friends arranged a carpool for their weekly art class.</td></tr>
<tr class='odd' id='enfr:59517'><td class='FrWrd' ><strong>carpool,<br> car pool</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (group of car sharers)</td><td class='ToWrd' >groupe de covoiturage <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>We added another driver to the carpool.</td></tr>
<tr class='even' id='enfr:71606'><td class='FrWrd' ><strong>carsick,<br> UK: car-sick,<br> car sick</strong> <em class='tooltip POS2'>adj<span><i>adjective</i>: Describes a noun or pronoun--for example, "a <b>tall</b> girl," "an <b>interesting</b> book," "a <b>big</b> house." </span></em></td><td> (nauseous from car travel)</td><td class='ToWrd' >malade en voiture <em class='tooltip POS2'>loc adj<span><i>locution adjectivale</i>: groupe de mots qui servent d'adjectif. Se place normalement après le nom et reste identique au pluriel<i>Ex : "ballon <b>de football</b>, des ballons <b>de football</b>"</i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >qui a le mal de la route <em class='tooltip POS2'>loc adj<span><i>locution adjectivale</i>: groupe de mots qui servent d'adjectif. Se place normalement après le nom et reste identique au pluriel<i>Ex : "ballon <b>de football</b>, des ballons <b>de football</b>"</i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>Reading in the car can make some people carsick.</td></tr>
<tr class='odd' id='enfr:3180052'><td class='FrWrd' ><strong>club car</strong> <em class='POS2'></em></td><td> (train car)&nbsp;<span class='dsense' >(<i>impropre mais courant</i>)</span></td><td class='ToWrd' >wagon-bar <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >voiture-bar <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:101049'><td class='FrWrd' ><strong>compact car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (small economical car)</td><td class='ToWrd' >voiture compacte, petite voiture <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>The company launched a new model of the compact car about a month ago.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>L'entreprise a lancé un nouveau modèle de voiture compacte (<i>or: </i> petite voiture) il y a environ un mois.</td></tr>
<tr class='odd' id='enfr:1117581'><td class='FrWrd' ><strong>convoy car</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >motrice <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:131097'><td class='FrWrd' ><strong>courtesy car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (vehicle provided free of charge)</td><td class='ToWrd' >véhicule de courtoisie <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>Al's Garage always lends me a courtesy car to drive while they repair my own car.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Le garage me prête toujours une voiture de courtoisie en attendant que ma voiture soit réparée.</td></tr>
<tr class='odd' id='enfr:101278'><td class='FrWrd' ><strong>dining car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (train carriage where food is served)</td><td class='ToWrd' >voiture-restaurant <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>impropre mais courant</i>)</span></td><td class='ToWrd' >wagon-restaurant <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>It's a good idea to reserve ahead if you want a table in the dining car.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>C'est une bonne idée de réserver à l'avance si vous voulez une table à la voiture-restaurant.</td></tr>
<tr class='even' id='enfr:114106'><td class='FrWrd' ><strong>electric car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (car powered by electricity)</td><td class='ToWrd' >voiture électrique <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>The auto industry needs to develop a cost-effective electric car.</td></tr>
<tr class='odd' id='enfr:3166025'><td class='FrWrd' ><strong>estate car,<br> estate</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>UK</i> (large automobile)&nbsp;<span class='dsense' >(<i>anglicisme : voiture</i>)</span></td><td class='ToWrd' >break <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >familiale <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:1177878'><td class='FrWrd' ><strong>family estate car</strong> <em class='POS2'></em></td><td> <i class='Fr2'>UK</i>&nbsp;<span class='dsense' >(<i>Automobile</i>)</span></td><td class='ToWrd' >familiale <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' id='enfr:114885'><td class='FrWrd' ><strong>freight car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (railway carriage for cargo)</td><td class='ToWrd' >wagon de marchandises <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The train was made up of about 40 freight cars.</td></tr>
<tr class='even' id='enfr:115074'><td class='FrWrd' ><strong>funny car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (type of drag racing)</td><td class='ToWrd' >dragster <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>They're called funny cars because the placement of the rear wheels gives them a funny appearance.</td></tr>
<tr class='odd' id='enfr:1189452'><td class='FrWrd' ><strong>gang car</strong> <em class='POS2'></em></td><td> <i class='Fr2'>US, rail</i>&nbsp;<span class='dsense' >(<i>chemin de fer</i>)</span></td><td class='ToWrd' >draisine <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:101842'><td class='FrWrd' ><strong>garage sale,<br> yard sale</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>US</i> (sale of used items)</td><td class='ToWrd' >vide-greniers <em class='tooltip POS2'>nm inv<span><i>nom masculin invariable</i>: nom masculin qui a la même forme au pluriel. <i>Ex : "un <b>?porte-clés</b>, des <b>porte-clés</b>"</i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>They sold a lot of their old things in a garage sale.  There is a car boot sale every week in the town's main car park.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Ils ont vendu leurs vieilles affaires dans un vide-greniers.  Il y a un vide-greniers toutes les semaines sur le plus grand parking de la ville.</td></tr>
<tr class='odd' id='enfr:1209818'><td class='FrWrd' ><strong>getaway car</strong> <em class='POS2'></em></td><td>&nbsp;<span class='dsense' >(<i>après une attaque à main armée</i>)</span></td><td class='ToWrd' >la voiture qui permet à <span title='quelqu&#39un'>[qqn]</span> de s'enfuir <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >la voiture des fuyards <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:1174936'><td class='FrWrd' ><strong>hatchback car</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >voiture avec hayon <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' id='enfr:116596'><td class='FrWrd' ><strong>hybrid car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (vehicle with combined power source)</td><td class='ToWrd' >voiture hybride <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>I bought a hybrid car to avoid high gasoline costs.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>J'ai acheté une voiture hybride pour faire des économies d'essence.</td></tr>
<tr class='even' id='enfr:1068626'><td class='FrWrd' ><strong>in-car</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >en voiture <em class='POS2'></em></td></tr>
<tr class='odd' id='enfr:133874'><td class='FrWrd' ><strong>jump a car</strong> <em class='tooltip POS2'>v expr<span><i>verbal expression</i>: Phrase with special meaning functioning as verb--for example, "put their heads together," "come to an end."</span></em></td><td> <i class='Fr2'>slang</i> (start a car using jump leads)</td><td class='ToWrd' >démarrer une voiture avec des câbles <em class='tooltip POS2'>loc v<span><i>locution verbale</i>: groupe de mots fonctionnant comme un verbe. <i>Ex : "faire référence à"</i></span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The battery was dead, so I had to jump-start the car.</td></tr>
<tr class='even' id='enfr:1116145'><td class='FrWrd' ><strong>mail car</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >wagon-poste <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:1180185'><td class='FrWrd' ><strong>mine car</strong> <em class='POS2'></em></td><td>&nbsp;<span class='dsense' >(<i>Industrie minière</i>)</span></td><td class='ToWrd' >herscher <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' id='enfr:134785'><td class='FrWrd' ><strong>model car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (miniature or toy vehicle)</td><td class='ToWrd' >voiture miniature <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' id='enfr:118846'><td class='FrWrd' ><strong>motor car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>dated</i> (car, automobile)</td><td class='ToWrd' >automobile <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:3181532'><td class='FrWrd' ><strong>observation car</strong> <em class='POS2'></em></td><td> (railroad passenger car)&nbsp;<span class='dsense' >(<i>Train</i>)</span></td><td class='ToWrd' >voiture panoramique <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' id='enfr:1194687'><td class='FrWrd' ><strong>open touring car</strong> <em class='POS2'></em></td><td> <i class='Fr2'>US</i></td><td class='ToWrd' >torpédo <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:3002777'><td class='FrWrd' ><strong>pace car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (in race)</td><td class='ToWrd' >voiture de tête, voiture pilote <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' id='enfr:3181588'><td class='FrWrd' ><strong>panda car</strong> <em class='POS2'></em></td><td> <i class='Fr2'>UK</i> (police car)</td><td class='ToWrd' >voiture de police <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>vieilli</i>)</span></td><td class='ToWrd' >voiture pie <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:120202'><td class='FrWrd' ><strong>parking lot,<br> car lot,<br> lot (US),<br> car park (UK)</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (vehicle parking area)</td><td class='ToWrd' >parking <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>Can</i>)</span></td><td class='ToWrd' >terrain de stationnement <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>Those high-school kids like to hang out in the parking lot and drink beer.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Ces lycéens aiment traîner dans le parking et boire de la bière.</td></tr>
<tr class='odd' id='enfr:120251'><td class='FrWrd' ><strong>passenger car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (carriage of a train)</td><td class='ToWrd' >voiture <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The ticket inspector walked through the passenger car and checked all the tickets.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'><span class='tooltip'><b>ⓘ</b><span>This sentence is not a translation of the original sentence.</span></span> Un TGV est composé de voitures de première classe, de voitures de deuxième classe et d'une voiture-bar</td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >voiture de voyageurs <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >wagon de voyageurs <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even' id='enfr:103983'><td class='FrWrd' ><strong>patrol car,<br> squad car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (on-duty police automobile)</td><td class='ToWrd' >voiture de police, voiture de patrouille <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>Slow down to the speed limit -- there's a patrol car around the bend.  I pulled over when I saw the patrol car's lights in my rear-view mirror.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Ralentis sous la vitesse autorisée, il y a une voiture de police dans le virage.  Je me suis rangé quand j'ai vu les phares de la voiture de police dans mon rétroviseur.</td></tr>
<tr class='odd' id='enfr:120700'><td class='FrWrd' ><strong>police car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (vehicle used by police)</td><td class='ToWrd' >voiture de police <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>We arrived to see a police car outside our home.  Within minutes of the alarm going off, 12 police cars were surrounding the building.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Quand nous sommes rentrés, nous avons vu qu'il y avait une voiture de police devant chez nous.  Quelques minutes après le déclenchement de l'alarme, il y avait déjà douze voitures de police autour du bâtiment.</td></tr>
<tr class='odd'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>familier</i>)</span></td><td class='ToWrd' >voiture de flics <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Quand nous sommes rentrés, nous avons vu qu'il y avait une voiture de flics devant chez nous.  Quelques minutes après le déclenchement de l'alarme, il y avait déjà douze voitures de flics autour du bâtiment.</td></tr>
<tr class='even' id='enfr:1181257'><td class='FrWrd' ><strong>push-car trolley</strong> <em class='POS2'></em></td><td>&nbsp;<span class='dsense' >(<i>Chemin de fer</i>)</span></td><td class='ToWrd' >lorry <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:121231'><td class='FrWrd' ><strong>race car,<br> racing car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (high-powered motor vehicle for racing)</td><td class='ToWrd' >voiture de course <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd'><td>&nbsp;</td><td colspan='2' class='FrEx'>The race car sped round the track at 150 miles per hour.</td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>La voiture de course faisait des tours de piste à 250 kilomètres à l'heure.</td></tr>
<tr class='even' id='enfr:3172044'><td class='FrWrd' ><strong>railcar,<br> railroad car (US),<br> railway car,<br> railway carriage,<br> train carriage,<br> carriage (UK)</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (passenger coach of a train)&nbsp;<span class='dsense' >(<i>d'un train</i>)</span></td><td class='ToWrd' >voiture <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td class='To2'>&nbsp;<span class='dsense'>(<i>impropre mais courant</i>)</span></td><td class='ToWrd' >wagon <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' id='enfr:1217129'><td class='FrWrd' ><strong>railroad car</strong> <em class='POS2'></em></td><td> <i class='Fr2'>US</i></td><td class='ToWrd' >voiture <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:127752'><td class='FrWrd' ><strong>rental car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (hired motor vehicle)</td><td class='ToWrd' >voiture de location <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>Please allow plenty of time for you to return your rental car.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Prévoyez suffisamment de temps pour rendre votre véhicule de location.</td></tr>
<tr class='odd' id='enfr:1136784'><td class='FrWrd' ><strong>rented car</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >voiture en location <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:121519'><td class='FrWrd' ><strong>restaurant car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (train carriage with buffet)</td><td class='ToWrd' >wagon-restaurant <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>We dined in the restaurant car while passing through the Swiss Alps.</td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Nous avons dîné dans le wagon-restaurant pendant que le train traversait les Alpes suisses.</td></tr>
<tr class='even'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >voiture-restaurant <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Nous avons dîné dans la voiture-restaurant pendant que le train traversait les Alpes suisses.</td></tr>
<tr class='even'><td>&nbsp;</td><td>&nbsp;</td><td class='ToWrd' >voiture-bar <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even notePubl_tr' ><td colspan='3' class='notePubl' ><i>Note</i>: En France, sur trains Corail et TGV.</td></tr><tr class='even' ><td>&nbsp;</td><td colspan='2' class='ToEx'>Nous avons dîné dans la voiture-bar pendant que le train traversait les Alpes suisses.</td></tr>
<tr class='odd' id='enfr:1092605'><td class='FrWrd' ><strong>rocket car</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >voiture-fusée <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:136947'><td class='FrWrd' ><strong>safety car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (motorsport: vehicle that sets slow pace)&nbsp;<span class='dsense' >(<i>Course automobile</i>)</span></td><td class='ToWrd' >voiture de sécurité <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even'><td>&nbsp;</td><td colspan='2' class='FrEx'>After the crash the safety car led the race cars at a slow pace while the wreckage was cleared.</td></tr>
<tr class='odd' id='enfr:3166105'><td class='FrWrd' ><strong>saloon car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> <i class='Fr2'>UK</i> (car: sedan)</td><td class='ToWrd' >berline <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:1171741'><td class='FrWrd' ><strong>saloon car</strong> <em class='POS2'></em></td><td> (GB)&nbsp;<span class='dsense' >(<i>Automobile</i>)</span></td><td class='ToWrd' >x <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' id='enfr:122387'><td class='FrWrd' ><strong>sleeping car</strong> <em class='tooltip POS2'>n<span><i>noun</i>: Refers to person, place, thing, quality, etc. </span></em></td><td> (train carriage fitted with bed)</td><td class='ToWrd' >wagon-lit <em class='tooltip POS2'>nm<span><i>nom masculin</i>: s'utilise avec les articles <b>"le", "l'" </b>(devant une voyelle ou un h muet), <b>"un"</b>. <i>Ex : garçon - nm > On dira "<b>le</b> garçon" ou "<b>un</b> garçon". </i></span></em></td></tr>
<tr class='odd' ><td>&nbsp;</td><td colspan='2' class='ToEx'>J'ai réservé une couchette dans le wagon-lit.</td></tr>
<tr class='even' id='enfr:3182229'><td class='FrWrd' ><strong>slot car</strong> <em class='POS2'></em></td><td> (miniature racing car)&nbsp;<span class='dsense' >(<i>jouet</i>)</span></td><td class='ToWrd' >petite voiture (sur circuit électrique) <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='odd' id='enfr:3182241'><td class='FrWrd' ><strong>smoking car</strong> <em class='POS2'></em></td><td> (smoking compartment)&nbsp;<span class='dsense' >(<i>train</i>)</span></td><td class='ToWrd' >voiture fumeurs <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
<tr class='even' id='enfr:1095280'><td class='FrWrd' ><strong>sport car</strong> <em class='POS2'></em></td><td></td><td class='ToWrd' >voiture de sport <em class='tooltip POS2'>nf<span><i>nom féminin</i>: s'utilise avec les articles <b>"la", "l'" </b>(devant une voyelle ou un h muet), <b>"une"</b>. <i>Ex : fille - nf > On dira "<b>la</b> fille" ou "<b>une</b> fille".</i> Avec un nom féminin, l'adjectif s'accorde. En général, on ajoute un "e" à l'adjectif. Par exemple, on dira "une petit<b>e</b> fille".</span></em></td></tr>
</table>
<table class='WRreporterror'>
<tr class='odd more'><td><a href='/enfr/car?start=100' style='font-weight:bold;'>100 prochains mots</a></td>
<td style='text-align:right;'><a target='WRsug' title='Is something important missing? Report an error or suggest an improvement.' href="/english/suggestions.aspx?w=car&amp;dict=enfr">Un oubli important ? Signalez une erreur ou suggérez une amélioration.</a></td></tr></table>

</div>
<div id="collinsdiv"></div>
<div id="article">

<!--<div style="margin-bottom: 30px;">Click the Collins tab</div>-->
	<div id='FTintro'>'<b>car</b>' found in these entries
</div>
<div class='FTsource'>In the English description:</div><div class='FTlist'>
<a href="/enfr/accelerate">accelerate</a>
 - <a href="/enfr/accident">accident</a>
 - <a href="/enfr/auto%20part">auto part</a>
 - <a href="/enfr/auto%20racing">auto racing</a>
 - <a href="/enfr/automatic">automatic</a>
 - <a href="/enfr/automobile">automobile</a>
 - <a href="/enfr/backseat%20driver">backseat driver</a>
 - <a href="/enfr/banger">banger</a>
 - <a href="/enfr/battery">battery</a>
 - <a href="/enfr/be%20picked%20up">be picked up</a>
 - <a href="/enfr/beat-up%20car">beat-up car</a>
 - <a href="/enfr/Beetle">Beetle</a>
 - <a href="/enfr/black%20and%20white">black and white</a>
 - <a href="/enfr/blue%20light">blue light</a>
 - <a href="/enfr/body">body</a>
 - <a href="/enfr/body%20panel">body panel</a>
 - <a href="/enfr/bone%20shaker">bone shaker</a>
 - <a href="/enfr/bonnet">bonnet</a>
 - <a href="/enfr/booster%20seat">booster seat</a>
 - <a href="/enfr/boot">boot</a>
 - <a href="/enfr/brake%20drum">brake drum</a>
 - <a href="/enfr/break%20in">break in</a>
 - <a href="/enfr/breakdown">breakdown</a>
 - <a href="/enfr/bubble%20car">bubble car</a>
 - <a href="/enfr/bumper%20sticker">bumper sticker</a>
 - <a href="/enfr/cabriolet">cabriolet</a>
 - <a href="/enfr/camber">camber</a>
 - <a href="/enfr/car%20hood">car hood</a>
 - <a href="/enfr/car%20lot">car lot</a>
 - <a href="/enfr/car%20payment">car payment</a>
 - <a href="/enfr/car%20ride">car ride</a>
 - <a href="/enfr/car%20seat">car seat</a>
 - <a href="/enfr/carful">carful</a>
 - <a href="/enfr/carjack">carjack</a>
 - <a href="/enfr/carjacker">carjacker</a>
 - <a href="/enfr/carjacking">carjacking</a>
 - <a href="/enfr/carload">carload</a>
 - <a href="/enfr/carpool">carpool</a>
 - <a href="/enfr/carport">carport</a>
 - <a href="/enfr/carriage">carriage</a>
 - <a href="/enfr/carsharing">carsharing</a>
 - <a href="/enfr/carsick">carsick</a>
 - <a href="/enfr/chairlift">chairlift</a>
 - <a href="/enfr/chauffeur">chauffeur</a>
 - <a href="/enfr/chauffeur-driven">chauffeur-driven</a>
 - <a href="/enfr/Chevy">Chevy</a>
 - <a href="/enfr/chop%20shop">chop shop</a>
 - <a href="/enfr/club%20car">club car</a>
 - <a href="/enfr/clunker">clunker</a>
 - <a href="/enfr/coachbuilder">coachbuilder</a>
</div>
<div class='FTsource'>
French:</div>
<div class='FTlist'>
<a href="/fren/bagnole">bagnole</a>
 - <a href="/fren/caisse">caisse</a>
 - <a href="/fren/char">char</a>
 - <a href="/fren/voiture%20de%20tourisme">voiture de tourisme</a>
 - <a href="/fren/voiture">voiture</a>
 - <a href="/fren/tire">tire</a>
 - <a href="/fren/accident">accident</a>
 - <a href="/fren/accident%20de%20la%20route">accident de la route</a>
 - <a href="/fren/accident%20de%20voiture">accident de voiture</a>
 - <a href="/fren/alarme%20anti-vol">alarme anti-vol</a>
 - <a href="/fren/anglaise">anglaise</a>
 - <a href="/fren/argus">argus</a>
 - <a href="/fren/assurance%20auto">assurance auto</a>
 - <a href="/fren/assurance%20automobile">assurance automobile</a>
 - <a href="/fren/atelier%20de%20carrosserie">atelier de carrosserie</a>
 - <a href="/fren/attentat%20%c3%a0%20la%20voiture%20pi%c3%a9g%c3%a9e">attentat à la voiture piégée</a>
 - <a href="/fren/auto">auto</a>
 - <a href="/fren/auto-couchette">auto-couchette</a>
 - <a href="/fren/auto-%c3%a9cole">auto-école</a>
 - <a href="/fren/auto-tamponneuse">auto-tamponneuse</a>
 - <a href="/fren/automitrailleuse">automitrailleuse</a>
 - <a href="/fren/automobile">automobile</a>
 - <a href="/fren/automobilisme">automobilisme</a>
 - <a href="/fren/automobiliste">automobiliste</a>
 - <a href="/fren/autopartage">autopartage</a>
 - <a href="/fren/autoradio">autoradio</a>
 - <a href="/fren/balade%20en%20voiture">balade en voiture</a>
 - <a href="/fren/benne">benne</a>
 - <a href="/fren/bolide">bolide</a>
 - <a href="/fren/braderie">braderie</a>
 - <a href="/fren/branche%20automobile">branche automobile</a>
 - <a href="/fren/break">break</a>
 - <a href="/fren/cam%c3%a9ra%20embarqu%c3%a9e">caméra embarquée</a>
 - <a href="/fren/car-ferry">car-ferry</a>
 - <a href="/fren/carrosserie">carrosserie</a>
 - <a href="/fren/carrossier">carrossier</a>
 - <a href="/fren/carte%20grise">carte grise</a>
 - <a href="/fren/centre%20auto">centre auto</a>
 - <a href="/fren/chrome%20de%20voiture">chrome de voiture</a>
 - <a href="/fren/club%20automobile">club automobile</a>
 - <a href="/fren/comp%c3%a9tition%20automobile">compétition automobile</a>
 - <a href="/fren/concept%20car">concept car</a>
 - <a href="/fren/concession%20automobile">concession automobile</a>
 - <a href="/fren/constructeur%20automobile">constructeur automobile</a>
 - <a href="/fren/cosy">cosy</a>
 - <a href="/fren/coup%c3%a9%20de%20ville">coupé de ville</a>
 - <a href="/fren/course%20de%20stock-car">course de stock-car</a>
 - <a href="/fren/course-poursuite">course-poursuite</a>
 - <a href="/fren/d%c3%a9passer%20une%20voiture">dépasser une voiture</a>
 - <a href="/fren/descendre%20d%27une%20voiture">descendre d'une voiture</a>
</div><br />

</div>

<div id="postArticle">
<div class='extras even'><div><span class='extra_category'>In Lists: </span><a href='https://lists.wordreference.com/show/top-2000-english-words.1/'>Top 2000 English words</a>, <a href='https://lists.wordreference.com/show/commerical-vehicles.10/'>Commerical vehicles</a>, <a href='https://lists.wordreference.com/show/vehicles.28/'>Vehicles</a>, <a href='https://lists.wordreference.com/'> more...</a></div><div><span class='extra_category'>Synonyms: </span><a href='/enfr/auto'>auto</a>, <a href='/enfr/passenger car'>passenger car</a>, <a href='/enfr/motor car'>motor car</a>, <a href='/enfr/wheels'>wheels</a>, <a href='/enfr/automobile'>automobile</a>, <a href='/synonyms/car'> more...</a></div><div><span class='extra_category'>Collocations: </span>a [red, fuel-efficient, safe, used, new, secondhand, rental] car, car [rentals, dealers, repairs, insurance], a [classic, vintage, sports, family, smart, muscle] car, <a href='/EnglishCollocations/car'> more...</a></div></div><br><p id='threadsHeader'>Discussions du forum dont le titre comprend le(s) mot(s) "car" :</p><div id="lista_link"><a target='_blank' href='https://forum.wordreference.com/threads/carry-as-in-a-car.495851/'>&#39;carry&#39; as in a car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/%c2%a32000-off-in-exchange-for-a-car-more-than-10-years-old.1373467/'>&#163;2000 off in exchange for a car more than 10 years old</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/850-horsepower-car.3403621/'>850-horsepower car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/90-degree-turn-with-a-car.3389133/'>90 degree turn (with a car)</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-21-56-no-max-car-rental.1787380/'>A 21.56 no max (car rental)</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-500-mile-per-gallon-car.1596134/'>a 500-mile-per-gallon car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-box-car.1617784/'>a box car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-car-driven-away.1944474/'>A car driven away</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-car-of-couple-of-ladies.480285/'>a car of couple of ladies</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-car-rammed-into-a-wall-and-was-then-torched.2283717/'>a car rammed into a wall and was then torched</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-car-ran-over-him-her.2831469/'>a car ran over him , her</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-car-that-smelled.2063548/'>a car that smelled</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-car-this-size.1109064/'>a car this size</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-car-too-hot.2800845/'>a car too hot</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-car-transporter-truck.2123058/'>A car transporter (truck)</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-conservative-car.2429938/'>a conservative car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-person-wants-to-get-his-car-washed.851725/'>A person wants to get his car washed</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-plushy-plush-car.2582445/'>a plushy-plush car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-rear-car.1321530/'>A rear car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-sixteen-hundred-car.2318444/'>a sixteen hundred car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-smooth-car.3170380/'>A smooth car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-three-car-funeral.2055939/'>a three-car funeral</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-vintage-car-from-the-late-1950s-early-1960s.2275127/'>A vintage car from the late 1950&#39;s/early 1960&#39;s</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/a-voir-si-on-laisse-car-peut-se-calculer.2200252/'>A voir si on laisse car peut se calculer</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/accessible-by-car.3265476/'>accessible by car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/aggressive-car.825158/'>aggressive car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/aire-de-camping-car.1395366/'>aire de camping-car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/all-i-want-is-my-own-car.117682/'>all I want is my own car</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/all-points-vision-car.3219074/'>all-points vision (car)</a><br>
<a target='_blank' href='https://forum.wordreference.com/threads/almost-hit-by-a-car.1969843/'>almost hit by a car</a><br>
<a href="/enfr/forumtitles/car" title='more...'><strong>Suite...</strong></a></div><div id='extra_links'><a href='https://forum.wordreference.com/forums/3/' title="Visit the French-English Forum">Visitez le forum French-English.</a><a href='https://forum.wordreference.com/forums/3/' title="Ask in the forums yourself">Aidez WordReference : Posez la question dans les forums.</a><a href='/definition/car#threadsHeader'><span class='boxed last' title='Discussions in the monolingual forum'>Discussions sur &#39;car&#39; dans le forum English Only</span></a></div>
		<span style="border: 0 none;" id="gtrans" dir="auto"><a href="#" rel="nofollow" onclick="iframeGGapi(); return false">Voir la traduction automatique de Google Translate de 'car'.</a><br></span>
		<script type="text/javascript">
		function iframeGGapi() {
			var sOriginal = 'car';
			var DestLang = "fr";
			var SourceLang = "en";
			document.getElementById('gtrans').innerHTML = "<iframe style='border: 0 none;' src='/2012/GoogTranslate.aspx?dict=" + SourceLang + DestLang + "&w=" + sOriginal + "&sk=t' width='100%' height='55'><\/iframe>";
			}
		</script>
		<p class='other_languages'>Dans d&#39;autres langues : <a href="/es/translation.asp?tranword=car">espagnol</a> | <a href="/enit/car">italien</a> | <a href="/enpt/car">portugais</a> | <a href="/enro/car">roumain</a> | <a href="/ende/car">allemand</a> | <a href="/ennl/car">néerlandais</a> | <a href="/ensv/car">suédois</a> | <a href="/enru/car">russe</a> | <a href="/enpl/car">polonais</a> | <a href="/encz/car">tchèque</a> | <a href="/engr/car">grec</a> | <a href="/entr/car">turc</a> | <a href="/enzh/car">chinois</a> | <a href="/enja/car">japonais</a> | <a href="/enko/car">coréen</a> | <a href="/enar/car">arabe</a> </p>
<div id="oldaudiospan"></div>
</div>
<script type='text/javascript' src='/2012/scripts/bundle.min.js?v=14122017102046'></script>

<script type="text/javascript">
var oTabHC = document.getElementById('tabHC'), oTabWR = document.getElementById('tabWR'), oTabRev = document.getElementById('tabRev');
 function loadCollinsJS() {
	var sWord = 'car', sDic = 'enfr', getCollins = document.createElement("script");
	getCollins.type = "text/javascript";
	getCollins.src = "/2012/collins/loadCollins.aspx?dict=" + sDic + "&w=" + sWord;
    getCollins.onload = function() {
        oTabHC.className= 'selected';
    };
	document.body.appendChild(getCollins);
    var ah2 = document.getElementById('mobileAd_holder2');
    if (ah2)
    {
        ah2.style.display = '';
        ah2.appendChild(document.getElementById('mobileAd'));
    }
	return false;
 }
if (oTabHC && oTabWR)
    {
// only run if both WR and HC tabs
 	var idWRD = document.getElementById('articleWRD');
    
 oTabHC.onclick = loadCollinsJS;
 oTabWR.onclick = function() {
	idWRD.style.display = 'block';
	idWRD.style.clear = 'both';
	document.getElementById('collinsdiv').style.display = 'none';
    var ah2 = document.getElementById('mobileAd_holder2');
    if (ah2)
    {
        ah.appendChild(document.getElementById('mobileAd'));
        ah2.style.display = 'none';
    }
	oTabWR.className= 'selected';
	oTabHC.className= '';
    if (oTabWR.querySelector('a'))
        location.href = oTabWR.querySelector('a').href;
	return false;
 };
if (oTabRev) {
    oTabRev.onclick = function() {
	    idWRD.style.display = 'block';
	    idWRD.style.clear = 'both';
	    document.getElementById('collinsdiv').style.display = 'none';
        var ah2 = document.getElementById('mobileAd_holder2');
        if (ah2)
        {
            ah.appendChild(document.getElementById('mobileAd'));
            ah2.style.display = 'none';
        }
	    oTabRev.className= 'selected';
	    oTabHC.className= '';
        location.href = oTabRev.querySelector('a').href;
	    return false;
     };
}
 if (localStorage.getItem) {
 // if set, then load HC
  var HCsetDate = localStorage.getItem("HCdefault"),
	now = new Date().getTime();
  if ((now-HCsetDate<2629740000)&&(!(window.location.search.indexOf("start=")>0))){loadCollinsJS();}
 }
 //  if no WRD content, load HC
 if(idWRD && idWRD.innerHTML.length < 10){loadCollinsJS();}
}
</script>

</td>

<!-- right column -->
<td id="rightcolumn">
	<table class="rightcolumn">
        <tr style='width:100%'><td colspan='2' style='text-align:center;color:gray;'>Publicités</td></tr><tr style='width:100%'><td colspan='2' id='adrighttop' style='max-height:250px;border-bottom: solid 1px #dcdcdc;padding-bottom:5px'><script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
<!-- 99_300x250A_GAS_Revised -->
<ins class="adsbygoogle"
     style="display:inline-block;width:300px;height:250px"
     data-ad-client="ca-pub-9302359610136232"
     data-ad-slot="1190977849"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script><script>var ad_tmp = new Object(); ad_tmp.per='1'; ad_tmp.id='26'; window.top.AdsRecord.push(ad_tmp);</script></td></tr><tr style='width:100%;'><td class='ad' colspan='2' style='padding:0;text-align:center;border-bottom:solid 1px #dcdcdc;border-collapse:collapse'><p style='display:block;margin: 8px 0 8px 0;'><span id='wotdCalendar' style='background-position:0px -39px;background-repeat:no-repeat;'></span><span style='font-weight:bold;position:relative;top:-3px;'>Word of the day: <a href='http://daily.wordreference.com/' style='font-weight:normal'>spread | rake</a></span></p></td></tr><tr style='width:100%'><td colspan='2' style='text-align: center;color: gray;'>Publicités</td></tr><tr><td id ='adrightbottom' class='ad' style='max-height:250px;'></td></tr><tr style='width:100%;'><td class='ad' colspan='2' style='text-align:center;border-bottom:solid 1px #dcdcdc;border-collapse:collapse'><p style='margin-right:-2px'><a id='GooglePlay' href='https://play.google.com/store/apps/details?id=com.wordreference' title='Android App' style='background-position:0px -60px;background-repeat:no-repeat;'></a><a href='http://itunes.apple.com/us/app/wordreference-dictionary/id515127233?mt=8&uo=4' id='AppStore' title='iPhone App' style='background-position:0px -110px;background-repeat:no-repeat;'></a></td></tr><tr style='width:100%'><td colspan='2'><a href="/docs/report.ad.aspx?country=JP&amp;number=9" target="_blank" title="Report an inappropriate ad." style="font-size:12px;text-align:left;margin-left:5px;">Signalez une publicité qui vous semble abusive.</a></td></tr><tr style='width:100%'><td colspan='2' style='border-top:solid 1px #dcdcdc;border-collapse:collapse;font-size:12px;text-align:left;padding-left:5px;padding-top:10px'><a href="/docs/supporter.aspx" target="_blank" title="WordReference Supporter - no ads">Devenez parrain de WordReference pour voir le site sans publicités.</a></td></tr>
<script type="text/javascript">
function isFirefox() { return (navigator.userAgent.indexOf('Firefox') > 0);}
function isChrome() { return (navigator.userAgent.indexOf('Chrome') > 0);}
if (isFirefox()) {document.writeln('<tr><td colspan="2"><div dir="auto" class="FCboxes" title="Firefox users: use search shortcuts for the fastest search of WordReference."><b style="color:red">Utilisateurs Firefox :<\/b> utilisez <a href="\/tools\/Firefox-search-shortcut.aspx">les raccourcis de recherche<\/a> pour une recherche plus rapide de WordReference.<\/div></td></tr>');}
if (isChrome()) {document.writeln('<tr><td colspan="2"><div dir="auto" class="FCboxes" title="Raccourci pour Chrome"> <b style="color:red">Utilisateurs de Chrome :<\/b> Utilisez <a href="\/tools\/Chrome-search-shortcut.aspx">les raccourcis de recherche<\/a> pour chercher plus rapidement sur WordReference.<\/div></td></tr>');}
</script>
	</table>
</td>

</tr>
</table>
</div>

<div id='ad1_holder' style='position: absolute;top: 44px;margin-left: 7%;'><script>parent.window.resizeWR(728);</script><script type='text/javascript'>
var googletag = googletag || {};
googletag.cmd = googletag.cmd || [];
(function() {
var gads = document.createElement('script');
gads.async = true;
gads.type = 'text/javascript';
var useSSL = 'https:' == document.location.protocol;
gads.src = (useSSL ? 'https:' : 'http:') + 
'//www.googletagservices.com/tag/js/gpt.js';
var node = document.getElementsByTagName('script')[0];
node.parentNode.insertBefore(gads, node);
})();
</script>

<script type='text/javascript'>
googletag.cmd.push(function() {
googletag.defineSlot('/1005951/728_WORLDWIDE_99', [728, 90], 'div-gpt-ad-1404179205514-0').addService(googletag.pubads());
googletag.pubads().enableSingleRequest();
googletag.enableServices();
});
</script>
<!-- 728_WORLDWIDE_99 -->
<div id='div-gpt-ad-1404179205514-0' style='width:728px; height:90px;'>
<script type='text/javascript'>
googletag.cmd.push(function() { googletag.display('div-gpt-ad-1404179205514-0'); });
</script>
</div><script>var ad_tmp = new Object(); ad_tmp.per='1'; ad_tmp.id='327'; window.top.AdsRecord.push(ad_tmp);</script></div>
<div id="footer">
<table class='footer'><tr><td><a href="/english/copyright.asp">Copyright</a> © 2018 WordReference.com</td><td style="text-align:right;" title="Please report any problems."><a href="https://forum.wordreference.com/misc/contact">Signalez</a> un éventuel problème.</td></tr></table>
</div>
</div>

<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>


<script type="text/javascript">
window.onresize= function(){
		return moveWHLinks();
	}

var moveWHLinks = function (){
	if(document.body.offsetWidth < 769){
		if (!document.getElementById('WHlinksmoved')){
			var WHspan = document.createElement("span");
				if (document.getElementById("WHlinks")){
                    WHspan.innerHTML = document.getElementById("WHlinks").innerHTML.replace(/\|/gi, '');
                    WHspan.innerHTML = WHspan.innerHTML.replace('WHlinks_forMobile', 'WHlinks_onMobile');
					WHspan.id = 'WHlinksmoved';
					document.getElementById("footer").insertBefore(WHspan, document.getElementById("footer").children[0]);
				}
			}
		}	
	};

moveWHLinks();	

//for placeholder text to fade on focus
if (document.getElementById("si")){
	document.getElementById("si").onfocus = function(){
		document.getElementById("si").placeholder = '';
	};
}
</script>

<!--[if lt IE 9]>
<script type="text/javascript">
if (document.getElementById("listen_widget")){
	function addUpgradeNotice(){
		if (!document.getElementById("audtag")){
			if (!document.getElementById("ieupgrade")){
				var upgradeDiv = document.createElement("div");
				upgradeDiv.id = 'ieupgrade';
				upgradeDiv.innerHTML = 'L&#39;audio sur WordReference marche mieux avec la dernière version d&#39;Internet Explorer. <a target="_blank" href="http://windows.microsoft.com/en-US/internet-explorer/downloads/ie/">Passez à la dernière version maintenant !</a>';
				document.getElementById("listen_widget").parentElement.insertBefore(upgradeDiv, document.getElementById("listen_widget").nextSibling);
			}
		}
	}
	
	document.getElementById("listen_widget").onclick = function(){
		return addUpgradeNotice();
	}
	function dismissUpgrade(){
		document.getElementById("ieupgrade").parentElement.removeChild(document.getElementById("ieupgrade"));
	}

}
</script>
<![endif]-->


<!-- Google Code for Remarketing tag -->
<div style="display:none;"> 
<img height="1" width="1" style="border-style:none;" alt="" src="//googleads.g.doubleclick.net/pagead/viewthroughconversion/1071834451/?value=0&label=4UQLCKyx-AQQ08qL_wM&guid=ON&script=0"/> 
</div>

<script>
    
    var dMatch = true;
    var fMatch = false;
    var isReverseDict = false;

    visitor = {
        browser: 1,
        browserOS: 3,
        browserVersion: 0,
        platform: 0,
        country: "JP"
    };
    


    window.onload = function () {
        if (AdsRecord.length > 0) {
            var json_ad = encodeURIComponent(JSON.stringify(AdsRecord));
            var scrt = document.createElement('script');
            scrt.type = 'text/javascript';
            scrt.src = 'https://www2.wordreference.com/2012/publ/saveimps.aspx?data=' + json_ad;
            scrt.onerror = function() {
                ga('send', { hitType: 'event', eventCategory: 'save_impressions_script', eventAction: 'failed'}, {nonInteraction: true});
            };
            document.getElementsByTagName('head')[0].appendChild(scrt);
        }        
    };
    


ga('send', 'event', 'site', 'www', {
  nonInteraction: true
});

//ga('send', { hitType: 'event', eventCategory: '', eventAction: 'www'}, {nonInteraction: true});


</script>
<script type="application/ld+json">
{
  "@context": "http://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [{
    "@type": "ListItem",
    "position": 1,
    "item": {
      "@id": "//www.wordreference.com/enfr/",
      "name": "English-French Dictionary"
    }
  },{
    "@type": "ListItem",
    "position": 2,
    "item": {
      "@id": "//www.wordreference.com/enfr/car",
      "name": "car"
    }
  }]
}
</script>
</body>
</html>
+    http_version:
+  recorded_at: Thu, 11 Jan 2018 07:10:19 GMT
+recorded_with: VCR 4.0.0

data/lib/wordref/version.rb CHANGED

@@ -1,3 +1,3 @@
 module Wordref
-  VERSION = "0.0.5"
+  VERSION = "0.0.8"
 end

data/spec/lib/wordref_spec.rb CHANGED

@@ -17,11 +17,14 @@
 #
 require 'wordref'
+require 'spec_helper'
 describe Wordref do
   it "can translate the word car in french" do
     tr = Wordref::Wordref.new
-    expect(tr.translate(from: 'en', to: 'fr', word: 'car')).to eq("voiture")
+    VCR.use_cassette 'wordef' do
+      expect(tr.translate(from: 'en', to: 'fr', word: 'car')).to eq("voiture")
+    end
   end
   it "should throw an error if chosen language is incorrect" do

data/spec/spec_helper.rb CHANGED

@@ -17,3 +17,13 @@
 #
 require 'wordref'
+require 'vcr'
+VCR.configure do |config|
+  config.cassette_library_dir = "fixtures/vcr_cassettes"
+  config.hook_into :webmock
+  config.stub_with :webmock
+  config.default_cassette_options = { :record => :new_episodes }
+end
+RSpec.configure do |config|
+end

data/wordref.gemspec CHANGED

@@ -16,8 +16,12 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
-  gem.add_dependency "multi_json"
-  gem.add_dependency "attempt"
-  gem.add_dependency "nokogiri"
+  gem.add_dependency "multi_json", '~> 1.12'
+  gem.add_dependency "attempt", '0.3'
+  gem.add_dependency "nokogiri", '~> 1.8'
   gem.add_development_dependency "rspec"
+  gem.add_development_dependency "vcr"
+  gem.add_development_dependency "webmock"
+  gem.add_development_dependency "fakeweb"
+  gem.add_development_dependency "rake"
 end

metadata CHANGED

@@ -1,23 +1,65 @@
 --- !ruby/object:Gem::Specification
 name: wordref
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.8
 platform: ruby
 authors:
 - pcboy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-02-07 00:00:00.000000000 Z
+date: 2018-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: attempt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -25,13 +67,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: attempt
+  name: vcr
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -39,13 +81,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -53,7 +95,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -79,6 +135,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- fixtures/vcr_cassettes/wordef.yml
 - lib/wordref.rb
 - lib/wordref/version.rb
 - spec/lib/wordref_spec.rb
@@ -103,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.4.5
+rubygems_version: 2.7.4
 signing_key:
 specification_version: 4
 summary: ''